Ghid practic pentru Programatori despre Retele Neuronale Convolutionale

Ca developer, abilitatea de a construi sisteme inteligente care pot lua decizii singure este unul dintre cele mai interesante aspecte ale tehnologiilor de ultima generatie. Unul dintre cele mai puternice instrumente pentru a realiza acest lucru este utilizarea algoritmilor de Machine Learning (ML). In acest articol, vom explora unul dintre cei mai populari algoritmi ML, Retelele neuronale convolutionale (CNNs).Va voi oferi exemple de cod pentru a va ajuta sa intelegeti cum implementati acest lucru in propriile proiecte.

CNN-urile sunt un tip de algoritmi de deep learning care sunt folositi frecvent pentru clasificarea imaginilor si recunoasterea obiectelor. Ideea de baza din spatele CNN-urilor este de a folosi o serie de straturi convolutionale si de pooling pentru a extrage caracteristici din imaginea de intrare, iar apoi de a folosi un strat complet conectat pentru a face predictia finala. Aceasta arhitectura le permite CNN-urilor sa invete ierarhii de caracteristici, unde fiecare strat extrage caracteristici la un nivel diferit de abstractie.

Pentru a incepe sa folosesti CNN-uri, va trebui sa instalezi biblioteca Keras, care este o biblioteca Python pentru construirea retelelor neuronale. O poti instala ruland urmatoarea comanda:

pip install keras

Odata ce ai instalat biblioteca, o poti importa si incepe sa construiesti modelul tau. Iata un exemplu de cum poti folosi CNN-uri pentru a clasifica imagini cu cifre scrise de mana:

from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras.utils import to_categorical

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(60000, 28, 28, 1)
X_test = X_test.reshape(10000, 28, 28, 1)

y_train = to_categorical(y_train)
y_test = to_categorical(y_test)

model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(10, activation='softmax'))

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

model.fit(X_train, y_train, epochs=5, batch_size=32)

accuracy = model.evaluate(X_test, y_test, verbose=0)
print("Accuracy:", accuracy[1])

In acest exemplu, mai intai incarcam setul de date MNIST, care este un set de imagini cu cifre scrise de mana, din biblioteca Keras. Apoi, redimensionam datele pentru a avea forma (60000, 28, 28, 1) pentru setul de antrenament si (10000, 28, 28, 1) pentru setul de testar, apoi convertim etichetele.

We then define the architecture of our CNN model using the Sequential API from Keras. We start by adding a convolutional layer with 32 filters, a kernel size of (3, 3) and a ReLU activation function, followed by a max-pooling layer to reduce the spatial

Imagineaza-ti ca lucrezi la un proiect in care vrei sa prezici daca o imagine contine un caine sau o pisica, bazandu-te pe pixeli imaginii. Iata un exemplu de cum poti folosi algoritmul CNN pentru a prezice daca este vorba despre o pisica sau un caine, folosind modelul pre-antrenat "VGG16" din Keras:

from keras.applications import VGG16
from keras.preprocessing.image import load_img
from keras.preprocessing.image import img_to_array
from keras.applications.vgg16 import preprocess_input
from keras.applications.vgg16 import decode_predictions

# load the model
model = VGG16()

# load an image from file
image = load_img('dog.jpg', target_size=(224, 224))

# convert the image pixels to a numpy array
image = img_to_array(image)

# reshape data for the model
image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2]))

# prepare the image for the VGG model
image = preprocess_input(image)

# predict the probability across all output classes
yhat = model.predict(image)

# convert the probabilities to class labels
label = decode_predictions(yhat)

retrieve the most likely result, e.g. highest probability
label = label[0][0]

print the classification
print('%s (%.2f%%)' % (label[1], label[2]*100))

In acest exemplu, mai intai incarcam modelul pre-antrenat VGG16 din biblioteca Keras. Apoi, incarcam o imagine cu un caine si o convertim intr-un array numpy. Redimensionam datele pentru a avea forma (1, 224, 224, 3), care este forma de intrare pe care o cere modelul VGG16. Apoi, pregatim imaginea pentru modelul VGG16 aplicand preprocess_input. In final, prezicem probabilitatea ca imaginea sa contina un caine sau o pisica, apeland metoda predict pe model si folosim decode_predictions pentru a converti probabilitatile in etichete de clasa si a obtine rezultatul cel mai probabil.

Este important de mentionat ca utilizarea modelelor pre-antrenate, cum ar fi VGG16, poate economisi mult timp si resurse si ofera, de asemenea, rezultate bune. Totusi, este important sa observi ca acest model a fost antrenat pe un set de date imens si poate sa nu functioneze bine pe imagini care sunt foarte diferite de cele pe care a fost antrenat. De asemenea, poti ajusta modelul prin adaugarea sau eliminarea unor straturi pentru a-l face mai potrivit pentru problema ta specifica.