Лабораторная работа №4

Разработка простейшей нейронной сети

Нейронная сеть — это метод в искусственном интеллекте, который учит компьютеры обрабатывать данные таким же способом, как и человеческий мозг. Это тип процесса машинного обучения, называемый глубоким обучением, который использует взаимосвязанные узлы или нейроны в слоистой структуре, напоминающей человеческий мозг. Он создает адаптивную систему, с помощью которой компьютеры учатся на своих ошибках и постоянно совершенствуются. Таким образом, искусственные нейронные сети пытаются решать сложные задачи, такие как резюмирование документов или распознавание лиц, с более высокой точностью.

Пример работы нейрона сети

Вначале импортируем библиотеку numpy

import numpy as np

Предположим, что нам известны вес и рост трех человек

data = {

'Иван': [84, 180, 1], 'Мария': [57, 165, 0], 'Анна': [62, 170, 0]

}

#и даны следующие веса и смещение w1, w2, b = 0.3, 0.1, -39

#теперь сделаем расчет для Ивана

#вначале умножим веса на данные и прибавим смещение r = w1 * data['Иван'][0] + w2 * data['Иван'][1] + b

#теперь пропустим результат через сигмоиду np.round(1 / (1 + np.exp(-r)), 3)

0.985

Пройдемся по ключам и значениям нашего словаря с помощью метода .items()

for k, v in data.items():

#вначале умножим каждую строчку данных на веса и прибавим смещение r1 = w1 * v[0] + w2 * v[1] + b

#затем применим сигмоиду

r2 = 1 / (1 + np.exp(-r1))

# если результат больше 0,5, модель предскажет мужской пол if r2 > 0.5:

38

print(k, np.round(r2, 3), 'male')

# в противном случае, женский else:

print(k, np.round(r2, 3), 'female')

Иван 0.985 male Мария 0.004 female Анна 0.032 female

Пример сети распознавания цифры с помощью библиотеки Keras

#установим библиотеку tensorflow (через нее мы будем пользоваться keras) и модуль mnist

#!pip install tensorflow mnist

Подготовка данных

Импортируем библиотеку метод fetch_openml для подгрузки рукописных цифр (набор mnist)

from sklearn.datasets import fetch_openml

from sklearn.model_selection import train_test_split

# и библиотеку keras

from tensorflow import keras

Выполнил импорт датасета цифр и разделим его на тренировочную и тестовую части

mnist = fetch_openml('mnist_784', as_frame=False, cache=False)

X = mnist.data.astype('float32') y = mnist.target.astype('int64')

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)

# посмотрим на размерность print(X_train.shape) print(y_train.shape) print(y_train) print(X_train)

(52500, 784) (52500,)

[3 2 8 ... 1 0 0] [[0. 0. 0. ... 0. 0. 0.]

[0. 0. 0. ... 0. 0. 0.]

39

[0. 0. 0. ... 0. 0. 0.]

...

[0. 0. 0. ... 0. 0. 0.] [0. 0. 0. ... 0. 0. 0.] [0. 0. 0. ... 0. 0. 0.]]

# посмотрим в каком формате сохранились наши данные type(X_train)

numpy.ndarray

#сделаем то же самое с тестовыми данными

#X_test = mnist.test_images()

#y_test = mnist.test_labels()

#и также посмотрим на размерность print(X_test.shape) print(y_test.shape)

(17500, 784) (17500,)

для примера построим первые 5 изображений и их метки.

import matplotlib.pyplot as plt

for i, (img, y) in enumerate(zip(X[:5].reshape(5, 28, 28), y[:5])): plt.subplot(151 + i)

plt.imshow(img)

plt.xticks([])

plt.yticks([])

plt.title(y)

#функция np.min() возвращает минимальное значение,

#np.ptp() - разницу между максимальным и минимальным значениями (от англ. peak to peak)

X_train = 2. * (X_train - np.min(X_train)) / np.ptp(X_train) - 1

X_test = 2. * (X_test - np.min(X_test)) / np.ptp(X_test) - 1

# снова воспользуемся функцией np.ptp() np.ptp(X_train)

2.0

40

"вытянем" (flatten) наши изображения, с помощью метода reshape у нас будет 784 столбца (28 х 28), количество строк Питон посчитает сам (-1)

X_train = X_train.reshape((-1, 784))

X_test = X_test.reshape((-1, 784))

# посмотрим на результат print(X_train.shape) print(X_test.shape)

(52500, 784) (17500, 784)

Посмотрим на первое изображение [0], пиксели с 200 по 209

X_train[0][200:210]

7. Конфигурация нейронной сети

#импортируем класс Sequential

from tensorflow.keras.models import Sequential

#и создадим объект этого класса model = Sequential()

#импортируем класс Dense

from tensorflow.keras.layers import Dense

#и создадим первый скрытый слой (с указанием функции активации и размера входного слоя)

model.add(Dense(64, activation = 'sigmoid', input_shape = (784,)))

#затем второй скрытый слой

model.add(Dense(64, activation = 'sigmoid'))

# и наконец выходной слой model.add(Dense(10, activation = 'softmax'))

6.Настройка нейросети

#укажем настройки модели (см. страницу занятия) model.compile(

loss = 'categorical_crossentropy',

optimizer = 'sgd', metrics = ['accuracy']

)

4.Обучение

41

# вначале импортируем функцию to_categorical, чтобы сделать one-hot encoding

from tensorflow.keras.utils import to_categorical

# обучаем модель методом .fit() model.fit(

X_train, # указываем обучающую выборку

to_categorical(y_train), # делаем one-hot encoding целевой переменной epochs = 10 # по сути, эпоха показывает сколько раз алгоритм пройдется по

всем данным

)

Epoch 1/10

1641/1641 [==============================] - 16s 9ms/step - loss: 2.0974 - accuracy: 0.4198

Epoch 2/10

1641/1641 [==============================] - 7s 4ms/step - loss: 1.4158 - accuracy: 0.6899

Epoch 3/10

1641/1641 [==============================] - 7s 4ms/step - loss: 0.8965 - accuracy: 0.7990

Epoch 4/10

1641/1641 [==============================] - 7s 4ms/step - loss: 0.6564 - accuracy: 0.8440

Epoch 5/10

1641/1641 [==============================] - 8s 5ms/step - loss: 0.5287 - accuracy: 0.8684

Epoch 6/10

1641/1641 [==============================] - 5s 3ms/step - loss: 0.4533 - accuracy: 0.8835

Epoch 7/10

1641/1641 [==============================] - 7s 4ms/step - loss: 0.4056 - accuracy: 0.8923

Epoch 8/10

1641/1641 [==============================] - 7s 4ms/step - loss: 0.3728 - accuracy: 0.8987

Epoch 9/10

1641/1641 [==============================] - 7s 4ms/step - loss: 0.3486 - accuracy: 0.9042

Epoch 10/10

1641/1641 [==============================] - 7s 4ms/step - loss: 0.3296 - accuracy: 0.9082

<keras.callbacks.History at 0x7f4d344f4e10>

Оценка качества модели

# для оценки модели воспользуемся методом .evaluate() model.evaluate(

X_test, # который применим к тестовым данным

to_categorical(y_test) # не забыв закодировать целевую переменную через

42

one-hot encoding

)

547/547 [==============================] - 3s 5ms/step - loss: 0.3293 - accuracy: 0.9084

[0.3293392062187195, 0.9083999991416931]

1.Прогноз

#передадим модели последние 10 изображений тестовой выборки pred = model.predict(X_test[-10:])

#посмотрим на результат для первого изображения из десяти pred[0]

array([9.9483841e-06, 9.4663680e-01, 1.1755496e-02, 5.5760136e-03, 1.1227399e-03, 6.8111289e-03, 1.3419950e-03, 1.4067567e-03, 2.4545800e-02, 7.9312979e-04], dtype=float32)

#для кажого изображения (то есть строки, axis = 1)

#выведем индекс (максимальное значение), это и будет той цифрой, которую мы прогнозируем

print(np.argmax(pred, axis = 1))

#остается сравнить с целевой переменной

print(y_test[-10:])

[1 5 8 8 2 9 6 5 9 2] [1 5 2 8 2 9 6 5 8 2]

1. Пример улучшения алгоритма

#снова укажем настройки модели model.compile(

loss = 'categorical_crossentropy',

optimizer = 'adam', # однако заменим алгоритм оптимизации metrics = ['accuracy']

)

#обучаем модель методом .fit()

model.fit(

X_train, # указываем обучающую выборку

to_categorical(y_train), # делаем one-hot encoding целевой переменной epochs = 10 # прописываем количество эпох

)

Epoch 1/10

1641/1641 [==============================] - 12s 6ms/step - loss: 0.2722 - accuracy: 0.9215

Epoch 2/10

1641/1641 [==============================] - 9s 5ms/step - loss: 0.1800 - accuracy: 0.9480

43