Ghid practic pentru Programatori despre Retele Neuronale Convolutionale

Ca dezvoltator, capacitatea de a construi sisteme inteligente care pot lua decizii pe cont propriu este unul dintre cele mai interesante aspecte ale lucrului cu tehnologia de ultimă generație. Unul dintre cele mai puternice instrumente pentru a realiza acest lucru este utilizarea algoritmilor de învățare automată (ML). În acest articol, voi analiza unul dintre cei mai populari algoritmi ML, Rețelele neuronale convoluționale (CNN), și voi oferi un exemplu de cod pentru a vă ajuta să înțelegeți cum să le implementați în propriile proiecte.

CNN sunt un tip de algoritm de învățare profundă care este utilizat în mod obișnuit pentru clasificarea imaginilor și recunoașterea obiectelor. Ideea de bază din spatele CNN este de a utiliza o serie de straturi convoluționale și de pooling pentru a extrage caracteristici din imaginea de intrare, apoi de a utiliza un strat complet conectat pentru a face predicția finală. Această arhitectură permite CNN să învețe ierarhii de caracteristici, în care fiecare strat extrage caracteristici la un nivel diferit de abstractizare.

Pentru a începe să utilizați CNN-urile, va trebui să instalați Keraslibrary, care este o bibliotecă de nivel înalt pentru construirea rețelelor neuronale. O puteți instala executând următoarea comandă:

pip install keras

Odată ce ați instalat biblioteca, o puteți importa și puteți începe să vă construiți modelul. Iată un exemplu de utilizare a CNN-urilor pentru clasificarea imaginilor cu cifre scrise de mână:

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])

În acest exemplu, încărcăm mai întâi setul de date MNIST, care este un set de date cu cifre scrise de mână, din biblioteca Keras. Apoi, remodelăm datele pentru a avea forma (60000, 28, 28, 1) pentru setul de antrenament și (10000, 28, 28, 1) pentru setul de testare și convertim etichetele în format categoric.

Apoi definim arhitectura modelului nostru CNN folosind API-ul secvențial din Keras. Începem prin a adăuga un strat convoluțional cu 32 de filtre, o dimensiune a nucleului de (3, 3) și o funcție de activare ReLU, urmată de un strat max-pooling pentru a reduce spațiul

Să vedem acum un exemplu mai practic. Imaginați-vă că lucrați la un proiect în care doriți să preziceți dacă o imagine conține un câine sau o pisică, pe baza pixelilor imaginii. Iată un exemplu de utilizare a algoritmului CNN pentru a prezice pisica sau câinele folosind modelul pre-antrenat Keras numit „VGG16”:

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 # încărcați modelul
model = VGG16() # încărcați o imagine din fișier
image = load_img(«dog.jpg», target_size=(224, 224)) # convertiți pixelii imaginii într-un array numpy
image = img_to_array(image) # remodelează datele pentru model
image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2])) # pregătește imaginea pentru modelul VGG
image = preprocess_input(image) # prezice probabilitatea pentru toate clasele de ieșire
yhat = model.predict(image) # convertește probabilitățile în etichete de clasă
label = decode_predictions(yhat) recupera rezultatul cel mai probabil, de exemplu probabilitatea cea mai mare
label = label[0][0] imprimă clasificarea
print(«%s (%.2f%%)» % (label[1], label[2]*100))

În acest exemplu, încărcăm mai întâi modelul VGG16 pre-antrenat din biblioteca Keras. Apoi, încărcăm o imagine cu un câine și o convertim într-un array numpy. Apoi remodelăm datele pentru a avea forma (1, 224, 224, 3), care este forma de intrare acceptată de modelul VGG16. Apoi pregătim imaginea pentru modelul VGG16 aplicând preprocess_input. În final, prezicem probabilitatea ca imaginea să conțină un câine sau o pisică apelând metoda predict din model și folosim decode_predictions pentru a converti probabilitățile în etichete de clasă și a obține rezultatul cel mai probabil.

Este important de menționat că utilizarea modelelor pre-antrenate, cum ar fi VGG16, poate economisi mult timp și resurse și, de asemenea, oferă rezultate bune. Cu toate acestea, este important de reținut că acest model a fost antrenat pe un set de date uriaș și este posibil să nu funcționeze bine pe imagini care sunt foarte diferite de cele pe care a fost antrenat. De asemenea, puteți regla modelul adăugând mai multe straturi sau eliminând unele straturi pentru a-l face mai potrivit pentru problema dvs. specifică.