MINISTERUL EDUCAŢIEI AL REPUBLICII MOLDOVA

UNIVERSITATEA TEHNICĂ A MOLDOVEI

Facultatea Calculatoare, Informatică și Microelectronică

Departamentul Informatică și Ingineria Sistemelor

Raport
Lucrare de laborator Nr.3
La Inteligența artificială

A elaborat:

A verificat:

Chișinău, 2021
 Tema: Rețele Neuronale de generația II (multistrat), convolutionala

Sarcina: Rezolvarea unei probleme utilizând Rețele Neurale Multistrat sau convolutionale
din biblioteca Tensorflow.

Problema: Recunoașterea tipului de vestimentație.

1. Importarea bibliotecilor și setului de date.

1.1. Importarea bibliotecilor;

1.2. Importarea setului de date;

Setul de date conține 60000 de imagini pentru învățare și 10000 de imagini pentru verificare cît
de bine a reușit rețeau neuronală să le clasifice
1.3 Afișare unei imagini pentru antrenare

Deci, fiecare imagine reprezintă o un masiv(28pX28p ) în care variația pixelor variază de la 0-250

1.4. Biblioteca conține 10 clase de vestimentație:

.
1.5 Verificarea dacă setul de date funcționează prin afișarea primelor 10 imagini pentru antrenare.
 2. Construirea rețelei neuronale
2.1. Retea Neoronala Multistrat
Blocul de bază al unei rețele neuronale este un strat. Straturile extrag imagini din datele
care sunt introduse în ele.

Primul strat: keras.layers.flatten - convertește un format de imagine dintr-o

matrice bidimensională (28 x 28 pixeli) într-o singură dimensiune (28 * 28 = 784
pixeli). Al doilea strat: keras.layers.Dense – const[ din 128 neuroni
Al treilea strat: keras.layers.Dense – consta din 10 neuroni si returnează o matrice
de 10 estimări probabilistice care însumează 1. Fiecare nod conține un scor care indică
probabilitatea unei imagini aparținând uneia dintre cele 10 clase.

2.2. Pregatirea pentru invatare

Înainte ca modelul să fie pregătit pentru antrenament, trebuie să specificăm încă
câțiva parametri. Acestea sunt adăugate în etapa de compilare a modelului:
 3. Antrenarea modelului
Pentru a începe antrenamentul, apelați metoda model.fit, care se numește așa deoarece
„se potrivește” modelului pe datele de antrenament:

Pentru a invata o retea neuronala cu o aproximitatea trebuie timp mult pentru antrenare.
In cazul meu, pentru a ajunge la acuratetia 81%, am folosit in mediu 1200 de epoci(Epoch).

Concluzie: In acest laborator m-am instruit cum sa construiesc o rețea neuronală

convolutionala. Aplicind in practica am reusit sa clasific in zece clase cu diferite
imagini de îmbrăcăminte, cum ar fi adidași și cămăși.

Anexe
Cod sursă:

import tensorflow as
tf from tensorflow import
keras import numpy as np
import matplotlib.pyplot as plt

fashion_mnist = keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

plt.figure()
plt.imshow(train_images[563])
plt.colorbar()
plt.grid(False)
plt.show()

class_names = ['Tricou', 'Pantaloni', 'Pulover', 'Rochie', 'Palton',

'Sandală', 'Cămașă', 'Adidași', 'Sacou', 'Botină']

train_images = train_images / 255.0

test_images = test_images / 255.0

plt.figure(figsize=(
10,10)) for i in
range(25):
plt.subplot(5,5,i+1)
plt.xticks([])
plt.yticks([])
plt.grid(False)
 plt.imshow(train_images[i],
cmap=plt.cm.binary)
plt.xlabel(class_names[train_labels[i]])
plt.show()

model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dense(10, activation='softmax')
])

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

model.fit(train_images, train_labels, epochs=100)

test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)

print('\nPrecizia datelor de verificare', test_acc)

predictions = model.predict(test_images)

predictions[0]

np.argmax(predictions[0])

test_labels[0]

def plot_image(i, predictions_array, true_label, img):

predictions_array, true_label, img = predictions_array[i],
true_label[i], img[i] plt.grid(False) plt.xticks([]) plt.yticks([])

plt.imshow(img, cmap=plt.cm.binary)

predicted_label =
np.argmax(predictions_array) if
predicted_label == true_label:
color =
'blue' else:
color = 'red'

plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],

100*np.max(predictions_array),
class_names[true_label]),
color=color)

def plot_value_array(i, predictions_array, true_label):

 predictions_array, true_label = predictions_array[i],
true_label[i] plt.grid(False) plt.xticks([]) plt.yticks([])
thisplot = plt.bar(range(10), predictions_array, color="#777777")
plt.ylim([0, 1])
predicted_label = np.argmax(predictions_array)

thisplot[predicted_label].set_color('red')
thisplot[true_label].set_color('blue')

i = 1
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions, test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions, test_labels)
plt.show()

num_rows = 5 num_cols = 3 num_images

= num_rows*num_cols
plt.figure(figsize=(2*2*num_cols,
2*num_rows)) for i in range(num_images):
plt.subplot(num_rows, 2*num_cols, 2*i+1)
plot_image(i, predictions, test_labels,
test_images) plt.subplot(num_rows,
2*num_cols, 2*i+2) plot_value_array(i,
predictions, test_labels) plt.show()

img = test_images[0]

print(img.shape)

img = (np.expand_dims(img,0))

print(img.shape)

predictions_single = model.predict(img)

print(predictions_single)

plot_value_array(0, predictions_single, test_labels)

_ = plt.xticks(range(10), class_names, rotation=45)

np.argmax(predictions_single[0])