Список работ

Бартеньев О. В.

Классификация изображений нейронной сетью

Содержание

• Введение
• Описание наборов данных
• Загрузка данных
  • Загрузка MNIST
  • Загрузка EMNIST
  • Загрузка MNIST и EMNIST из бинарных файлов
  • Загрузка CIFAR-10
• Функции потерь
• Описание моделей нейронных сетей
• Параметры моделей нейронных сетей
• Сохранение и загрузка весов
• Оценка результатов обучения
• Погрешность измерения значения критерия
• Воспроизведение результатов обучения
• Обработка историй обучения
  • Поиск лучших решений
  • Потенциально лучшие решения
  • Выделение эффективных функций потерь
  • Диаграммы эффективности функций потерь
  • Графики обучения
  • Характеристики историй обучения
  • Модели НС с близкими списками эффективных функций потерь
• Пересечение списков неверно классифицированных изображений на тестовых данных
• Объединение прогнозов
• Списки эффективных функций потерь
• Заключение
• Источники
• Приложение 1. Результаты обучения нейронных сетей
• Приложение 2. Программа создания и обучения моделей НС
• Приложение 3. Программа загрузки и тестирования обученных моделей НС
• Приложение 4. Общие процедуры программ создания, обучения, загрузки и тестирования моделей НС
• Приложение 5. Программа обработки историй обучения
• Приложение 6. Обработка историй обучения
  • П6.1. Проверка историй обучения
  • П6.2. Два статистических показателя
  • П6.3. Поиск лучших решений
  • П6.4. Анализ одной модели
  • П6.5. Анализ одной (заданной) функции потерь
  • П6.6. Поиск лучших решений
  • П6.7. Некоторые характеристики обучения
  • П6.8. Вывод графиков обучения
  • П6.9. Диаграмма потенциально лучших решений
  • П6.10. Диаграмма частоты появления функций в списках эффективных функций моделей НС
  • П6.11. Диаграмма эффективности функций потерь
  • П6.12. Дополнительные характеристики истории обучения
  • П6.13. Вывод пар моделей с близкими списками эффективных функций потерь
  • П6.14. Вывод списка эффективных моделей
• Приложение 7. Код создания и обучения сети ResNet

Введение

Рассматривается задача классификация изображений, хранимых наборами данных MNIST [1], EMNIST-letters [2] и CIFAR-10 [3].
Решаются следующие задачи:

• выбираются структуры моделей нейронных сетей (НС);
• вводятся обозначения слоев моделей НС и выполняется описание структур моделей НС в виде строки, содержащей обозначения их слоев;
• создается программа построения модели НС по описанию ее структуры;
• выполняется обучение моделей НС; в процессе обучения фиксируется история обучения;
• создается отчет о результатах обучения моделей НС;
• разрабатываются программы обработки историй обучения с целью выявления лучших решений, эффективных функций потерь и других показателей;
• разрабатываются программы для графического отображения результатов обучения;
• выполняется повторное обучение моделей НС с целью выявления погрешности оценки результатов обучения.

Модели НС реализуются на языке программирования Python средствами библиотеки Keras.
Обучаются разные модели НС с применением различных функций потерь, предоставляемых библиотекой Keras.
Качество обучения оценивается по трем следующим критериям:

1. Точность классификации на тестовых данных.
2. Точность классификации на обучающих данных.
3. Суммарное число верно классифицированных изображений на тестовых и обучающих данных.

При представлении результатов обучения с целью повышения наглядности используется показатель "суммарное число ошибочно классифицированных изображений на тестовых и обучающих данных.

Описание наборов данных

Наборы данных содержат следующие изображения:

• MNIST – 70'000 рукописных цифр; из них 60'000 входят в обучающую выборку, а 10'000 – в тестовую; размер каждого образа – 28*28 пикселей; рисунки выполнены в оттенках серого цвета;
• EMNIST-letters – 145'600 рукописных букв английского алфавита; из них 124'800 входят в обучающую выборку, а 20'800 – в тестовую; размер каждого образа – 28*28 пикселей; рисунки выполнены в оттенках серого цвета;
• CIFAR-10 – 60'000 цветных рисунков следующих десяти классов: самолеты, легковые автомобили, птицы, кошки, олени, собаки, лягушки, лошади, корабли, грузовики; размер каждого образа – 32*32 пикселей. В обучающую выборку входят 50'000 рисунков, а 10'000 – в тестовую.

Замечание. Далее вместо EMNIST-letters будет употребляться EMNIST.

Примеры изображений наборов данных приведены на рис. 1-3.

Рис. 1. MNIST: примеры изображений

Рис. 2. EMNIST: примеры изображений буквы A

Рис. 3. CIFAR-10: примеры изображений

При необходимости здесь можно загрузить файлы с данными:

• MNIST;
• EMNIST;
• CIFAR-10.

Загрузка данных

Загрузка MNIST

В случае MNIST данные загружаются из следующих файлов:

• train-images-idx3-ubyte.gz; train-labels-idx1-ubyte – обучающие данные и их метки;
• t10k-images-idx3-ubyte, t10k-labels-idx1-ubyte – тестовые данные и их метки.

Загрузку и вывод девяти цифр обучающего набора MNIST обеспечивает следующий код:

from mnist import MNIST
import numpy as np
import matplotlib.pyplot as plt
pathToData = 'G:\\AM\\НС\\mnist\\'
mndata = MNIST(pathToData) # pathToData – ранее заданный путь к папке с данными
mndata.gz = True # Разрешаем чтение архивированных данных
imagesTrain, labelsTrain = mndata.load_training()# Обучающая выборка (данные и метки)
imagesTest, labelsTest = mndata.load_testing()# Тестовая выборка (данные и метки)
X_train = np.asarray(imagesTrain)
y_train = np.asarray(labelsTrain)
X_train = X_train.reshape(X_train.shape[0], 28, 28, 1)
# Выводим 9 изображений обучающего набора
names = []
for i in range(10): names.append(chr(48 + i)) # ['0', '1', '2', ..., '9']
for i in range(9):
    plt.subplot(3, 3, i + 1)
    ind = y_train[i]
    img = X_train[i][0:28, 0:28, 0]
    plt.imshow(img, cmap = plt.get_cmap('gray'))
    plt.title(names[ind])
    plt.axis('off')
plt.subplots_adjust(hspace = 0.5)
plt.show()

Загрузка EMNIST

При работе с EMNIST использованы те же средства ввода данных, что и для MNIST. Для этого выполнены приведенные в табл. 1 изменения имен файлов EMNIST (тип файлов – gz Archive):

Таблица 1. Переименования имен файлов EMNIST

Различия при вводе данных обусловлены тем, что в EMNIST буквы хранятся в горизонтальном положении и вдобавок отраженными относительно оси x (рис. 4).

Рис. 4. Буквы EMNIST без преобразований отражения и поворота

В программе после чтения файла буквы отражаются относительно оси x и поворачиваются на 90° по часовой стрелке:

X_train = X_train.reshape(X_train.shape[0], img_rows, img_cols, 1).transpose(0,2,1,3)
X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 1).transpose(0,2,1,3)

В принципе, сеть можно обучать, не подвергая таким преобразованиям обучающую и тестовую выборки, а выполнять эти преобразования лишь при выводе рисунков букв:

import numpy as np
from scipy import ndimage
...
let = X_test[0][0:28, 0:28, 0] # Первая буква тестового набора
let = let.reshape(32, 32)
let = np.flipud(let)
let = ndimage.rotate(let, -90)

или

let = let.reshape(32, 32).transpose()

Загрузка MNIST и EMNIST из бинарных файлов

Ввод данных будет выполнен быстрее, если их загружать из бинарных файлов.
Архивы таких файлы имеются для MNIST и EMNIST.

Код создания MNIST-бинарных файлов:

from mnist import MNIST
import numpy as np
# Прежде загружаем данные
mndata = MNIST(pathToData)
mndata.gz = True
imagesTrain, labelsTrain = mndata.load_training()
imagesTest, labelsTest = mndata.load_testing()
# Сохраняем данные в двоичные файлы
fn = open(pathToData + 'imagesTrain.bin', 'wb')
fn2 = open(pathToData + 'labelsTrain.bin', 'wb')
fn3 = open(pathToData + 'imagesTest.bin', 'wb')
fn4 = open(pathToData + 'labelsTest.bin', 'wb')
fn.write(np.uint8(imagesTrain))
fn2.write(np.uint8(labelsTrain))
fn3.write(np.uint8(imagesTest))
fn4.write(np.uint8(labelsTest))
fn.close()
fn2.close()
fn3.close()
fn4.close()
print('MNIST-данные сохранены в двоичные файлы')

Код чтения бинарных файлов (предварительно выполняется распаковка ранее загруженного архива с бинарными файлами):

def loadBinData(pathToData):
    import numpy as np
    print('Загрузка данных из двоичных файлов')
    with open(pathToData + 'imagesTrain.bin', 'rb') as read_binary:
        data = np.fromfile(read_binary, dtype = np.uint8)
    with open(pathToData + 'labelsTrain.bin', 'rb') as read_binary:
        labels = np.fromfile(read_binary, dtype = np.uint8)
    with open(pathToData + 'imagesTest.bin', 'rb') as read_binary:
        data2 = np.fromfile(read_binary, dtype = np.uint8)
    with open(pathToData + 'labelsTest.bin', 'rb') as read_binary:
        labels2 = np.fromfile(read_binary, dtype = np.uint8)
    return data, labels, data2, labels2
#
pathToData = 'G:\\AM\\НС\\mnist\\'
imagesTrain, labelsTrain, imagesTest, labelsTest = loadBinData(pathToData)
X_train = np.asarray(imagesTrain)
y_train = np.asarray(labelsTrain)
X_test = np.asarray(imagesTest)
y_test = np.asarray(labelsTest)
X_train = X_train.reshape(60000, 28, 28, 1)
X_test = X_test.reshape(10000, 28, 28, 1)

Загрузка CIFAR-10

CIFAR-10 загружается из файлов, расположенных в папке

pathToData + cifar-10-batches-py/

В этой папке файлы

data_batch_1, data_batch_2, data_batch_3, data_batch_4, data_batch_5

содержат обучающие данные, а файл

test_batch

содержит тестовые данные.

Размер каждого файла 30'309 КБ. Каждый файл содержит по 10'000 изображений и их метки.

Код загрузки CIFAR-10 и вывода 50-и случайных изображений обучающего набора:

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.font_manager as font_manager
#
def load_cifar10(pathToData): # pathToData – путь к папке с данными
    def unpickle(file):
        import pickle
        with open(file, 'rb') as fo:
            dict_file = pickle.load(fo, encoding = 'bytes')
        return dict_file
    fileNm = pathToData + 'cifar-10-batches-py/data_batch_'
    # Загрузка обучающих данных
    im_size = 32 * 32 * 3 # 3072
    X_train = np.zeros((50000, im_size), dtype = 'uint8')
    y_train = np.zeros(50000, dtype = 'uint8')
    m = -1
    for i in range(5):
        dict_i = unpickle(fileNm + str(i + 1))
        X = dict_i[b'data']
        Y = dict_i[b'labels']
        Y = np.array(Y)
        for k in range(10000):
            m += 1
            X_train[m, :] = X[k, :]
            y_train[m] = Y[k]
    X_train = X_train.reshape(50000, 3, 32, 32).transpose(0,2,3,1)
    # Загрузка тестовых данных
    len_test = 10000
    fileNm = pathToData + 'cifar-10-batches-py/test_batch'
    dict_i = unpickle(fileNm)
    X_test = dict_i[b'data']
    y_test = dict_i[b'labels']
    X_test = X_test.reshape(len_test, 3, 32, 32).transpose(0,2,3,1) # .astype('uint8')
    y_test = np.array(y_test)
    # Выводим 50 случайных изображений обучающего набора
    names = []
    names.append('Самолет')
    names.append('Авто')
    names.append('Птица')
    names.append('Кошка')
    names.append('Олень')
    names.append('Собака')
    names.append('Лягушка')
    names.append('Лошадь')
    names.append('Судно')
    names.append('Грузовик')
    fig, axs = plt.subplots(5, 10, figsize = (7, 4))
    title_font = {'fontname':'Arial', 'size':'9', 'color':'black'}
    for j in range(5):
        for k in range(10):
            i = np.random.choice(range(50000))
            ax1 = axs[j][k]
            ax1.set_axis_off()
            ax1.imshow(X_train[i])
            ax1.set_title(names[y_train[i]], **title_font)
    plt.subplots_adjust(hspace = 0.5, wspace = 0.0)
    plt.show()
pathToData = 'G:\\AM\\НС\\cifar10\\'
load_cifar10(pathToData)

Функции потерь

Обучение моделей НС выполняется с различными функциями потерь библиотеке Keras [4] на наборах данных MNIST, EMNIST и CIFAR-10.
Используемые функции потерь и их обозначения перечислены в табл. 2.

Таблица 2. Функции потерь библиотеки Keras

Кроме перечисленных в табл. 2. функций потерь, применяются:

• пользовательская функция myLoss (обозначение ml):
  def myLoss(y_true, y_pred):
      return = K.sqrt(K.sqrt(K.sum(K.square(K.square(y_pred - y_true)))))
• сумма функций потерь CCE + KLD (обозначение: CCE_KLD, или сокращенно ck):
  def cce_kld(y_true, y_pred):
      cce = K.categorical_crossentropy(y_true, y_pred)
      y_true = K.clip(y_true, K.epsilon(), 1)
      y_pred = K.clip(y_pred, K.epsilon(), 1)
      kld = K.sum(y_true * K.log(y_true / y_pred), axis = -1)
      return cce + kld
• сумма функций потерь 17 * MSE + KLD (обозначение: MSE_KLD, или сокращенно mk):
  def mse17_kld(y_true, y_pred):
      mse = K.mean(K.square(y_pred - y_true), axis = -1)
      y_true = K.clip(y_true, K.epsilon(), 1)
      y_pred = K.clip(y_pred, K.epsilon(), 1)
      kld = K.sum(y_true * K.log(y_true / y_pred), axis = -1)
      return 17.0 * mse + kld

Описание моделей нейронных сетей

Классификация изображений MNIST, EMNIST и CIFAR-10 выполняется с использованием сверточных НС (СНС), созданных на основе структуры, приведенной на рис. 5.

Рис. 5. Структура базовой СНС для MNIST, EMNIST и CIFAR-10

Построение СНС выполнялось в результате добавления слоев (сверточных, полносвязных, разреживающих и пакетной нормализации), также использовались и сборки СНС с двумя и тремя ветвями.
Поскольку СНС, построенные на базе приведенной на рис. 5 структуры, показали низкие результаты обучения на CIFAR-10, вдобавок была использована сеть ReNet20v1, показывающая, согласно [5], на CIFAR-10 точность классификации 91.25% на проверочных данных.
ReNet20v1 состоит секций, содержащих показанные на рис. 6 блоки.

Рис. 6. Блоки секций ResNet20v1

Всего в ReNet20v1 три секции. Первая секция состоит из трех а-блоков, вторая и третья – из б-блока и двух а-блоков (рис. 7).

Рис. 7. Структуры секций ResNet20v1

Полностью структура ReNet20v1 показана на рис. 8.

Рис. 8. Структура ResNet20v1

Кроме того, для MNIST использовались модели многослойного перцептрона (МП) и рекуррентной нейронной сети (РНС) с LSTM-слоем (рис. 9).

Рис. 9. Структуры НС: а – МП; б – РНС

Для вывода рис. 5 и 9 использована процедура plot_model:

import keras
from keras.utils import plot_model
model = createModel() # Формирование модели СНС
plot_model(model, to_file = 'cnn_graph.png') # Вывод графа модели СНС

Замечание. Для plot_model необходимо установить graphviz (нужна библиотека gvc.dll).

В MNIST и EMNIST изображения заданы в оттенках серого цвета на площадке размером 28*28 пикселей, что определяет следующую форму входа:

input_shape = (28, 28, 1)

В CIFAR-10 изображения цветные и имеют размер 32*32 пикселя, поэтому задаем следующую форму входа:

input_shape = (32, 32, 3)

Форма выходного слоя определяется числом классов. В MNIST и CIFAR-10 их 10, а в EMNIST – 26.

В табл. 3 приведены описания слоев одной моделей НС, использованной для MNIST, EMNIST и CIFAR-10.

Таблица 3. Описание слоев СНС c4 для MNIST, EMNIST и CIFAR-10

Описание слоев ResNet20v1 приведено в табл. 4.

Таблица 4. Описание слоев ResNet20v1 для CIFAR-10

Сведения, приведенные в табл. 3 и 4, получены в результате выполнения следующего кода:

model = createModel() # Формирование модели НС
model.summary() # Вывод сведений о слоях модели НС

Введем следующее полное обозначение слоя описанной в тпбл. 3 модели НС:

<Тип слоя>[<Вид функции активации>][<форма входа | число фильтров | нейронов>],

где <Тип слоя> – это символ I, C, D, P или F соответственно для входного, сверточного, полносвязного слоев или слоев подвыборки и преобразования многомерных данных в одномерные;
<Вид функции активации> – это символ R, L или S соответственно для функции активации ReLU, Linear или Softmax.
Для слоев типа P и F указанные в квадратных скобках компоненты обозначения отсутствуют.
Знак "|" использован для обозначения "или".
Запишем приведенные выше структуры СНС (кроме ResNet20v1) в виде следующих строк:

I(28,28,1)-CR20-P-CR30-P-F-DR600-DL30-DS10 # MNIST;
I(28,28,1)-CR20-P-CR30-P-F-DR600-DL30-DS26 # EMNIST;
I(32,32,3)-CR20-P-CR30-P-F-DR600-DL30-DS10 # CIFAR-10,

В дальнейшем, записывая таким образом структуру НС, будем опускать входной и выходной слои, например:

CR20-P-CR30-P-F-DR600-DL30.

Указание этой записи для MNIST означает, что на входе слой I(28,28,1), а на выходе DS10.
В случае EMNIST на входе I(28,28,1), а на выходе DS26.
В случае CIFAR-10 на входе I(32,32,3), а на выходе DS10.
Dropout-слой обозначается указанием параметра rate, задающего долю нейронов, исключаемых из модели НС, например, запись

CR20-P-CR30-P-F-0.25-DR600-DL16

означает, что перед полносвязным слоем

Dense(units = 600, activation = 'relu'...)

расположен слой

Dropout(rate = 0.25)

Присутствие слоя пакетной нормализации будем обозначать символами BN.

Обозначение LSTM-слоя рекуррентной сети (для слоя берется заданная по умолчанию функция активации):

Ln,

где n – размер выхода слоя.

Используя введенные обозначения, перечислим в табл. 5 модели НС, примененные для классификации изображений MNIST, EMNIST и CIFAR-10.

Таблица 5. Примененные модели НС

В некоторых случаях используется сборка НС, построенная на основе одной из описанных в табл. 5 моделей НС (пример сборки показан на рис. 10).

Рис. 10. Сборочная НС (2c8) с двумя ветвями на основе сети c8

В этом случае перед в обозначении сборочной сети указывается число ветвей и обозначение базовой структуры, например, 2c8.
Для объединения идущих по ветвям сборки данных используется слой Average. Иные способы объединения данных описаны в [6].
Модель с конкретной функцией потерь обозначается следующим образом:

• 2c12(kld) – первое обучение модели 2c12 с функцией потерь kld;
• 2c12_2(kld) – второе обучение модели 2c12 с функцией потерь kld.

Результаты обучения перечисленных в табл. 5 моделей НС с применением разных функций потерь, приведены в прил. "Результаты обучения нейронных сетей".

Параметры моделей нейронных сетей

В сетях различной структуры использованы следующие параметры:

• Затравка датчика случайных чисел seedVal = 348;
• Во всех сверточных слоях:
  • использована функция активации ReLU;
  • размер окна фильтра kernel_size = 3, если CIFAR-10, kernel_size = 4 – в противном случае;
  • шаг окна фильтра strides = 1;
  • способ заполнения padding = 'same';
• Во всех слоях подвыборки:
  • размер окна подвыборки pool_size = 2;
  • шаг окна подвыборки strides = 2;
  • способ заполнения padding = 'same';
• Во всех слоях Dropout параметр seed = seedVal: Dropout(drop_rate, seed = seedVal)
• Во всех слоях:
  • Инициализатор k_init = keras.initializers.RandomNormal(seed = seedVal);
  • use_bias = True;
  • bias_initializer = k_init
  • kernel_initializer = k_init
• Первый полносвязный слой моделей НС снабжен функцией активации ReLU.
• В случае трех полносвязных слоев второй слой имеет функцию активации Linear.
• Выходной слой всех моделях НС является полносвязным с функцией активации Softmax.
• Метод оптимизации Adam с заданными по умолчанию аргументами.
• Размер пакета обучения batch_size = 256;
• Число эпох обучения epochs = 120;
• Ранняя остановка keras.callbacks.EarlyStopping(monitor = 'loss', patience = 9).

Классификация изображений выполняется с применением перечисленных выше функций потерь.

Сохранение и загрузка весов

В процессе обучения веса (параметры) модели НС будут записаны в файл после завершения эпохи, если результаты оценки НС по точности классификации на проверочных данных (monitor = 'val_acc') после этой эпохи превосходят ранее полученные результаты. Это обеспечивает следующий код:

# Обеспечим сохранение обученной сети
suf = 'MNIST_mape_Adam_conv_' # Значение suf может быть иным
filesToSave = 'weights_' + suff + '.{epoch:02d}-{val_acc:.2f}.hdf5'
say = 'веса' if weightsOnly else 'модель и веса'
print('Сохраняем веса в файлы вида ' + filesToSave)
pathWeights = pathToData + filesToSave
# Сохраняем и веса, и модель: save_weights_only = False
checkpoint = keras.callbacks.ModelCheckpoint(pathWeights, monitor = 'val_acc', verbose = 0,
                                             save_weights_only = True,
                                             save_best_only = True, mode = 'max', period = 1)
callbacks_list = [checkpoint]
# Обучение
# Запоминаем историю обучения для последующего анализа и вывода графиков потерь и точности
history = model.fit(X_train, y_train, batch_size = batch_size, epochs = epochs,
                    verbose = 2, validation_data = (X_test, y_test), callbacks = callbacks_list)

Пример имени файла с весами: weights_MNIST_mape_Adam_c12.36-0.99.hdf5

В имени файла указаны имя набора данных, применяемые функция потерь (mape) и метод оптимизации (Adam), обозначение НС (c12), номер эпохи, после завершения которой сохранены веса (36), и точность классификации на проверочных данных с двумя знаками после запятой.
Сохраненные веса модели НС (назовем ее исходной) можно загрузить в программу, предварительно создав модель НС, совпадающую с исходной. Кроме того, в создаваемую для загрузки весов модель НС можно добавить слои Dropout, либо исключить эти слои при их наличии в исходной модели или изменить некоторые параметры модели НС, например, функции активации, не влияющие на число весов в модели.
Модель с закруженными весами можно употребить для следующих целей:

• продолжить обучение с той же функцией потерь, что и в исходной модели;
• продолжить обучение с другой функцией потерь;
• оценить модель на обучающем или тестовом наборе данных;
• получить массив, содержащий результат классификации произвольной выборки данных, например, обучающей или тестовой:
  y_pred = model.predict(X_test) # Результат классификации тестовой выборки

По полученному массиву y_pred можно, в частности, получить индексы неверно классифицированных изображений и вывести ошибочный прогноз и истинное имя классса или его метку:

# X - тестируемые данные
# y - метки тестируемых данных
# n - число тестируемых данных
imgType = 'MNIST' # или 'EMNIST' или 'CIFAR10'
y_pred = model.predict(X) # Предсказания модели НС на обучающей или тестовой выборке
# Заносим в список classes метки классов, предсказанных моделью НС
classes = []
for m in y_pred: classes.append(np.argmax(m))
# Число верно классифицированных изображений
nClassified = np.sum(classes == y)
# Число ошибочно классифицированных изображений
nNotClassified = n - nClassified
acc = 100.0 * nClassified / n
print("Число ошибочно классифицированных образов: " + str(nNotClassified))
print("Точность прогнозирования: " + str(acc) + '%')
print('Список неверно классифицированных изображений')
names = [] # Список с именами классов
if imgType == 'MNIST':
    for i in range(10): names.append(chr(48 + i)) # ['0', '1', '2', ..., '9']
elif imgType == 'EMNIST':
    for i in range(26): names.append(chr(65 + i)) # ['A', 'B', 'C', ..., 'Z']
elif imgType == 'CIFAR10':
    names.append('Самолет')
    names.append('Авто')
    names.append('Птица')
    names.append('Кошка')
    names.append('Олень')
    names.append('Собака')
    names.append('Лягушка')
    names.append('Лошадь')
    names.append('Судно')
    names.append('Грузовик')
# m - число ошибочных предсказаний
m = 0
for i in range(n):
    s_true = names[y[i]] # Истинное имя класса
    s_pred = names[classes[i]] # Предсказанное моделью имя класса
    if s_true != s_pred:
        m += 1
        if (m > nNotClassified): break
        print(str(m) + '. i = ' + str(i) + '. На самом деле: ' + s_true + '. Прогноз: ' + s_pred)

Оценку обученной модели НС можно выполнить, применив метод evaluate:

# Оценка модели НС на тестовых данных
score = model.evaluate(X_test, y_test, verbose = 0)
# Вывод потерь и точности
print('Потери при тестировании: ', score[0])
print('Точность при тестировании:', score[1])

Оценка результатов обучения

Введем следующие понятия:

• список обучения (СО) – список НС, обучаемых на наборе данных;
• эпизод – обучение модели НС с некоторой функцией потерь;
• цикл обучения – последовательное обучение модели НС с каждой из приведенных выше функцией потерь;
• история обучения – массивы значений точности классификации и потерь на обучающих и тестовых данных, фиксируемых после каждой эпохи обучения модели НС; история сохраняется в файлы: acc*.txt, loss*.txt, val_acc*.txt и val_loss*.txt;
• критерий обучения – показатель, используемый для оценки качества обучения, например, acc – точность классификации на обучаемых данных;
• решение – обученная модель НС;
• имя решения – имя модели НС с указанием номера обучения, функции потерь, критерия обучения и его значения и эпохи получения решения по следующему шаблону:

  <имя модели>_<номер обучения> (<функция потерь>, <критерий обучения> = <значение>, <эпоха>)

  Например: c1_2(msle, acc = 99.83, 44).

Примеры имен файлов с историей обучения:

• acc_MNIST_kld_Adam_c1.txt;
• loss_MNIST_kld_Adam_c1.txt;
• val_acc_MNIST_kld_Adam_c1.txt;
• val_loss_MNIST_kld_Adam_c1.txt.

В имени файла присутствуют имена набора данных, функции потерь, метода оптимизации и модели НС.
Файлы содержат вычисляемые после завершения каждой эпохи обучения значения следующих показателей:

• acc – точность классификации на обучающих данных;
• loss – значение функции потерь на обучающих данных;
• val_acc – точность классификации на проверочных данных;
• val_loss – значение функции потерь на проверочных данных.

Несколько строк из истории обучения c1(kld) приведены в табл. 6.

Таблица 6. Фрагмент истории обучения c1(kld)

Показатели acc, loss, val_acc и val_loss можно использовать для оценки качества обучения модели НС и выбора решения.
Введем еще один показатель:

corr_img – суммарное число правильно классифицированных изображений на обучающей и тестовых выборках.

Замечание. При выводе результатов для наглядности вместо corr_img используется значение err_img – суммарное число ошибочно классифицированных изображений на обучающих и проверочных данных:

err_img = all_img – corr_img,

где all_img – число изображений в наборе данных.

В дальнейшем показатели acc, loss, val_acc, val_loss и corr_img (err_img) будем называть критериями обучения.

В некоторых случая в истории обучения имеется эпоха, после которой acc и val_acc имеют (по сравнению с другими эпохами) максимальное значение, а loss, val_loss и err_img – минимальное.
Пример: модель c1(msle) после 44-й эпохи на MNIST:

acc = 99.845%; loss = 0.000133; val_acc = 99.52%; val_loss = 0.000416; err_img = 142.

В других эпохах обучения этой модели критерии обучения хуже.
Однако в большинстве случаев критерии обучения имеют наилучшие значения в разных эпохах; пример приведен в табл. 7.

Таблица 7. Лучшие эпохи (на MNIST) модели c17(sссe)

Замечание. Лучшие значения критериев обучения модели c17(sссe) в приведенной выше табл. 7 указаны полужирным шрифтом.

Таким образом, если лучшие значения критериев получены в разных эпохах, возникает задача выбора лучшего решения.
Нередко результаты обучения оцениваются по val_acc или по ошибке, равной 100 – val_acc (см., например, [7, 8]).
Такая оценка не дает полного представления о качестве обучения. Например, на MNIST максимум val_acc моделей c5(sh), c5(cce), c5(kld) и c5(pss) одинаков (val_acc = 99.4), однако значения acc и, следовательно, err_img различны (табл. 8):

Таблица 8. Сравнение решений с одинаковым val_acc

Учитывая эту информацию, лучшим следует признать решение c5(pss).

Замечание 1. При обучении минимизируется значение функции потерь (loss) на обучающих данных. Однако этот показатель, как следует из [7, 8], редко применяется при выборе решения.

В табл. 9 показано, насколько серьезно решения, выбранные по критериям acc, val_acc и err_img, отличаются по потерям от решения с наименьшими потерями (берутся потери на обучающей выборке).

Таблица 9. Среднее относительное отклонение по потерям между лучшими решениями и решениями с наименьшими потерями

Заполнение табл. 9 выполнено по следующему алгоритму:

Входные данные. Имя набора данных, критерий (acc, val_acc или err_img), список и истории обучения НС выбранного набора данных.
Выходные данные. loss_dif – среднее относительное отклонение (в %) по потерям между лучшими решениями и решениями с наименьшими потерями.

1. Сформировать список лучших решений (СЛР) по выбранному критерию.
2. loss_dif = 0 # Искомое среднее относительное отклонения по потерям
3. Для каждого решения из СЛР цикл:
       Найти потери loss_crit в эпохе лучшего решения.
       Найти эпоху с наименьшими потерями loss и потери loss_loss в этой эпохе.
       loss_dif = loss_dif + (loss_crit – loss_loss) / loss_loss
   конецЦикла
4. loss_dif = 100 * loss_dif / размер_СЛР

Погрешность измерения значения критерия

Измерение значения критерия – это обучение НС и последующая оценка обученной модели с целью вычисления значений критериев, которые и являются результатами измерений.
При работе с Keras при повторном обучении модели НС с неизмененными значениями параметров новое решение, если не принять специальных мер, как правило, отличается от прежнего. Примеры таких расхождений представлены в табл. 10, также такие примеры имеются и в прил. 1

Таблица 10. Результаты повторных обучений моделей НС

В нашем случае измерение – это обучение НС и последующие вычисления значений критериев.
Погрешность измерений вычислена по следующей формуле:

Δ_crit = (crit_max – crit_min) / 2,

Замечание 1. В приведенной выше таблице значения val_acc и acc берутся из файлов историй обучения. В файлах, хранящих acc, значения меньше, чем значения acc, полученные после оценки (evaluate) обученной модели НС или выполнения прогноза (prerdict). Например, для модели 2c28(lc) в файле acc_EMNIST_lc_Adam_2c28.txt после эпохи 61 имеем:

acc = 97.25%

После этой эпохи веса модели сохранены в файле weights_EMNIST_lc_Adam_2c28.61-0.95.hdf5 (val_acc после этой эпохи равен 95.03%).
После загрузки весов и выполнения оценки модели на обучающих данных имеем:

acc = 98.12%

То есть для этой модели err_img = 1052, а не 4466, как указано в табл. 9.
Такое расхождение объясняется тем, что при обучении берутся текущие значения acc, а при оценке класс определяется по наибольшему значению в выходном векторе. Например, текущий выход (случай двух классов) для объекта второго класса – это [0.2, 0.8], то есть точность 80%. Но при прогнозировании на обученной модели этот по этому вектору классифицируемый объект будет отнесен ко второму классу, то есть так же, как и при выходе [0.0, 1.0] (точность классификации 100%).

Замечание 2. Для функции потерь binary crossentropy в случае метрики 'accuracy' имеем завышенные значения точности.
Например, после 73-й эпохи обучения модели c7(bce) имеем на MNIST (эпоха 73 является лучшей по критерию val_acc):

val_acc = 99.89%

Однако после загрузки весов этой модели и выполнения evaluate (или predict) получим:

val_acc = 99.44%

Чтобы получить реальную точность, с binary crossentropy (lossFunNum == 11) используется вдобавок метрика categorical_accuracy:

metrics = ['accuracy', keras.metrics.categorical_accuracy] if lossFunNum == 11 else ['accuracy']

Замечание 3. В [9] погрешность измерений val_acc на EMNIST указывается равной ±0.12%.

Значение погрешности измерений val_acc может быть употреблено для поиска одинаково эффективных функций потерь: ФП одинаково эффективны, если значения val_acc, полученные в результате применения этих ФП, отличаются на величину, не превышающую погрешности измерения val_acc.
При поиске эффективных по val_acc ФП следует пользоваться погрешностью, найденной для ФП с большими значениями val_acc.
Используем для расчета средней величины погрешности следующие данные:

• MNIST: значения погрешностей функций, имеющих val_acc >= 99.57 – это:
  mse/0.02; msle/0.025; lc/0.025; scce/0.01; bce/0.025; ck/0.025; mk/0.04;
• EMNIST: значения погрешностей функций, имеющих val_acc >= 94.90 – это:
  mse/0.03; msle/0.025; lc/0.045; cce/0.08; cp/0.06;
• CIFAR-10: значения погрешностей функций, имеющих val_acc >= 91.00 – это:
  bce/0.22; kld/0.25; pss/0.235; cp/0.38.

Таким образом, в задаче поиска эффективных ФП можно сделать следующие оценки погрешности измерений val_acc:

• 0.024 в случае MNIST;
• 0.048 в случае EMNIST;
• 0.217 в случае CIFAR-10.

По мере накопления данных эти оценки могут корректироваться.

Воспроизведение результатов обучения

Воспроизведение результатов эпизода обучения обеспечивает следующий код [10], который должен быть исполнен до начала создания НС и ее обучения:

# Флаг задания режима воспроизведения результатов
repeat_results = False # True
seedVal = 348
import numpy as np
np.random.seed(seedVal) # Задание затравки датчика случайных чисел
#
if repeat_results:
    print('Режим воспроизведения (повторяемости) результатов')
    import random as rn
    import tensorflow as tf
    import os
    from keras import backend as K
    # Код, необходимый для воспроизведения результата
    os.environ['PYTHONHASHSEED'] = '0'
    rn.seed(seedVal)
    tf.set_random_seed(seedVal)
    session_conf = tf.ConfigProto(intra_op_parallelism_threads = 1,
                                 inter_op_parallelism_threads = 1)
    sess = tf.Session(graph = tf.get_default_graph(), config = session_conf)
    K.set_session(sess)

В этом коде фиксируются затравки датчиков случайных чисел, значение системной переменной PYTHONHASHSEED и устанавливается в сессии tensorFlow однопоточность.

Обработка историй обучения

Обработка историй обучений позволяет:

• находить лучшие решения по критериям err_img, val_acc и acc;
• выявлять эффективные функции потерь;
• строить диаграммы эффективности функций потерь;
• строить графики обучения;
• находить в решении наибольшее число эпох между двумя последовательными обновлениями максимума критерия обучения;
• находить в решении разницу значений критерия обучения для двух последних обновлений его максимума.

Поиск лучших решений

После завершения эпизода история обучения и веса обученной модели НС сохраняются в папку, имя которой согласуется с именем модели НС. Так, истории обучения и веса модели c1 будут записаны в папку w_1, с2 – в папку w_2 и так далее.
Лучшее решение ищется по критерию err_img, val_acc или acc.
При поиске просматриваются все файлы с историями обучения и в результате определяются модель НС и функция потерь, обеспечившие лучшее значение выбранного критерия обучения, а также эпоха, после завершения которой это значение было получено.
Дополнительно для этой модели выводятся сведения об эпохах с наименьшими потерями loss и val_loss, а также сведения об эпохах с наилучшими значениями двух других критериев обучения.
Результаты поиска лучших решений по всем наборам данных и историям обучения приведены в табл. 11.

Таблица 11. Лучшие решения

Замечание. Единственно ошибочно классифицируемое изображение из обучающей выборке MNIST моделью c6(kld) имеет индекс 59915 и в массиве меток y_train помечено как число 4:

y_train[59915] = 4

Это изображение (рис. 11) классифицируется моделью c6(kld) как число 7.

Рис. 11. Модель c6(kld) классифицирует это изображение как цифру 7

Поиск лучших решений по выбранному критерию выполняется в следующем порядке:

Входные данные:

• w_list – список директорий с историями решений;
• c_name – имя критерия.

Выходные данные: Список с описаниями лучших решений. Описание решения содержит:

• epoch_all – число эпох;
• epoch – эпоха лучшего решения;
• acc – точность на обучающих данных;
• loss – потери на обучающих данных;
• val_acc – точность на проверочных данных;
• val_loss – потери на проверочных данных;
• corr_img – число верно классифицированных изображений на обучающих и проверочных данных;
• fn – имя файла истории, содержащего лучшее решение, например, val_acc_MNIST_kld_Adam_c6.txt;
• dr – имя папки с лучшим решением;
• fun – имя функции потерь;
• p – путь к папке с лучшим решением.

1. Перебрать все истории обучения и найти список solve_list лучших решений по заданному критерию.
2. Если c_name = 'corr_img' Тогда
       Упорядочить solve_list по убыванию val_acc и возрастанию loss.
   Иначе
       Упорядочить solve_list по убыванию corr_img и возрастанию loss.
   КонецЕсли
   Взять первое решение из упорядоченного solve_list.
3. Вывести описание найденного решения.
4. Найти и вывести для найденной модели описания лучших эпох по двум другим критериям.
5. Найти и вывести для найденной модели описания лучших эпох по loss и val_loss.

Пример. Результат поиска лучшего решения на MNIST по corr_img:

Критерий: число ошибочно классифицированных изображений на обеих выборках
Число сканируемых директорий: 19
Набор данных: MNIST
Всего изображений: 70000
Лучшие решения:

1.
['val_acc_MNIST_kld_Adam_c6.txt', 'w_6', 'kld']
Всего эпох: 120
Описание эпох:
('Эпоха лучшего решения по err_img:', 60, 99.99833, 99.45, 0.000269, 0.037857, 56)
('Эпоха наибольшей точности acc:', 60, 99.99833, 99.45, 0.000269, 0.037857, 56)
('Эпоха наибольшей точности val_acc:', 60, 99.99833, 99.45, 0.000269, 0.037857, 56)
('Эпоха наименьших loss-потерь:', 119, 99.99833, 99.42, 0.000269, 0.04809, 59)
('Эпоха наименьших val_loss-потерь:', 5, 99.31, 99.19, 0.020668, 0.024443, 495)

Программа поиска лучших решений приведена в прил. 5.

Потенциально лучшие решения

По результатам обучения можно выявить решения, близкие к решениям, приведенным в табл. 11.
Примеры решений на MNIST, близких к решению c6(kld, err_img = 56, 61) приведены в табл. 12.

Таблица 12. Решение c6(kld, err_img = 56, 61) и близкие к нему решения на MNIST

Верхняя граница критерия err_img при составлении списка берется исходя из погрешности оценки результата обучения по этому показателю. Аналогичные списки можно составить и по критериям val_acc и acc.
Назовем решения, присутствующие в подобных списках, потенциально лучшими.
Диаграммы потенциально лучших решений по критерию err_img для разных наборов данных приведены на рис. 12.

Рис. 12. Потенциально лучшие решения по критерию err_img

Изображенные на рис. 12 диаграммы построены по приведенным в табл. 13 данным.

Вывод диаграммы потенциально лучших решений выполняет процедура plotBestResultsDiag программы обработки историй обучения.
В табл. 14 показаны потенциально лучшие решения по критерию val_acc.

Таблица 14. Потенциально лучшие решения по критерию val_acc

Выделение эффективных функций потерь

Приведенные в табл. 13 решения получены с применением разных функций потерь. Все они могут быть отнесены к числу наиболее эффективных функций потерь.
Составим по табл. 13 для MNIST список функций потерь:

[ [kld, 2, 56.5], [cce, 2, 58.5], [ck, 2, 58.5], [pss, 1, 57], [scce, 1, 59] ].

Элемент списка записан по следующему шаблону:

[<ФП>, <число появлений ФП в СПЛР>, <усредненное значение критерия обучения>],    (*)

где ФП – функция потерь;

СПЛР – список потенциально лучших решений.

Таким образом, для обучения на MNIST по критерию err_img могут быть рекомендованы следующие функции потерь: kld, cce, ck, pss и scce.
Составим по историям обучения списки эффективных функций потерь для всех наборов данных и всех критериев обучения, используя следующий алгоритм:

Входные данные: имя набора данных, имя критерия обучения, список директорий, хранящих истории обучения, погрешность оценки результатов обучения.

1. Получить СПЛР и описания решений.
2. Сформировать, используя шаблон (*), список функций потерь (СФП), обеспечивших получение потенциально лучших решений.
3. Упорядочить СФП по числу их появления в СПЛР и усредненному значению критерия обучения.
4. Предъявить упорядоченный СФП в качестве результата.

Функции потерь, выявленные по историям обучения моделей НС, приведены в табл. 15.

Таблица 15. Эффективные функции потерь

Диаграммы эффективности функций потерь

Диаграммы строятся по историям обучения после задания набора данных и вида критерия обучения.
Возможны три вида диаграмм:

1. Частотная, показывающая частоту появления функций потерь в списке эффективных функций потерь.
2. Средневзвешенная, показывающая усредненное для каждой функции потерь значение критерия обучения по всем или лучшим решениям.
3. Эффективность функций потерь при обучении одной модели НС.

Возможны три варианта построения диаграмм двух первых видов:

1. По потенциально лучшим решениям по всем моделям НС.
2. По потенциально лучшим решениям для каждой отдельно взятой модели НС.
3. По всем решениям для всех моделей НС.

В первом случае определяется лучшее решений по всем моделям, а затем к нему добавляются решения, близкие по заданному критерию обучения; функции потерь, обеспечившие эти решения, считаются эффективными.
Во втором случае выполняется перебор моделей НС, определяется лучшее решение для текущей модели НС, далее к нему добавляются решения, близкие по заданному критерию обучения; функции потерь, обеспечившие эти решения добавляются в список эффективных функций потерь.
В третьем случае имеет смысл только средневзвешенная диаграмма, поскольку на частной для каждой функции будет получена одинаковая частота, равная числу используемых моделей НС.
На рис. 13 показаны частотные диаграммы, отвечающие первым двум случаям; по оси абсцисс отложены имена функций потерь, а по оси ординат – частота появления функций в списке эффективных функций потерь, сформированном по историям обучения; функции упорядочены по возрастанию частоты.

Рис. 13. Частотные диаграммы эффективности функций потерь:
а – по потенциально лучшим решениям для всех моделей НС (mean_eff_all = False, one_dir = 0, showFreqDiag = True);
б – по потенциально лучшим решениям каждой модели НС (mean_eff_all = False, one_dir = 2, showFreqDiag = True)

Диаграммы, показанные на рис. 13, а, построены по данным, приведенным в табл. 16.

Таблица 16. Частота появления функций потерь в списке потенциально лучших решений для всех моделей НС

Диаграммы, показанные на рис. 13, б, построены по данным, приведенным в табл. 17.

Таблица 17. Частота появления функций потерь в списке потенциально лучших решений для каждой модели НС

На рис. 14 показаны средневзвешенные диаграммы для решений, полученных на разных наборах данных; по оси абсцисс так же отложены имена функций потерь, а по оси ординат – значения критерия обучения, усредненные для лучших (рис. 14, а) и всех (рис. 14, б) решений.

Рис. 14. Средневзвешенные диаграммы эффективности функций потерь на всех моделях НС по критерию обучения err_img:
а – отобраны только лучшие решения (mean_eff_all = False, one_dir = 0);
б – взяты все решения (mean_eff_all = True, one_dir = 0)

Перед выводом диаграммы (рис. 14) данные сортируются по убыванию err_img.

На диаграммах (рис. 15) показана эффективность функций потерь, примененных на EMNIST для модели 2c28, по критерию val_acc; по оси абсцисс отложены имена функций потерь, а по оси ординат – значения критерия обучения.

Рис. 15. Диаграмма эффективности функций потерь для 2c28 на EMNIST по критерию val_acc:
а – только лучшие решения;
б – все решения

Вывод диаграмм обеспечивает процедура plotDiags программы обработки историй обучения.

Графики обучения

На рис. 16-18 показаны графики обучения (изменения точности и потерь) для лучших решений на EMNIST по критериям err_img, val_acc и acc.
По оси абсцисс отложены номера эпох, а по оси ординат – либо точность классификации, либо потери.
Лучшее решение выбрано после обучения 30 моделей. Каждая модель обучалась на EMNIST с применением 16-и функций потерь.

Рис. 16. График обучения лучшего решения по критерию err_img

Рис. 17. График обучения лучшего решения по критерию val_acc

Рис. 18. График обучения лучшего решения по критерию acc

Из приведенных графиков видно, что НС, выбранные по критериям err_img (рис. 16) и acc (рис. 18), являются переобученными (снижение потерь на обучающем множестве сопровождается ростом потерь на оценочном множестве). Устранение причин, вызывающих переобучение, приведет к росту качества обучения по всем трем используемым критериям.

Вывод графиков обучения выполняет следующая процедура:

def plot_hist(is_acc, sva, crit_list, pref_list, imgType, crit, d):
    import matplotlib.pyplot as plt # Например, d = ' / '
    # crit_list:
    # [epoch_all, epoch, acc, loss, val_acc, val_loss, corr_img, fn, dr, fun, p]
    bias = 7 if sva < 2 else 3 # sva = 1 (2) - Точность на тестовых (обучающих) данных
    fn = crit_list[7]
    dr = crit_list[8]
    fun = crit_list[9]
    p = crit_list[10]
    base = fn[bias:]
    ttl = imgType + d + crit + d + fun + d + dr
    if is_acc:
        ks = 0
        lb = 'acc'
        lb2 = 'val_acc'
        loc = 'lower right'
    else:
        ks = 1
        lb = 'loss'
        lb2 = 'val_loss'
        loc = 'center right'
    acc_loss = readFile(p + pref_list[ks] + base)
    val_acc_loss = readFile(p + pref_list[ks + 2] + base)
    plt.figure(figsize = (5, 2))
    plt.plot(acc_loss, color = 'r', label = lb, linestyle = '--')
    plt.plot(val_acc_loss, color = 'g', label = lb2)
    plt.title(ttl)
    plt.legend(loc = loc)
    plt.show()

Характеристики историй обучения

Определяются следующие характеристики историй обучения:

• расстояние между эпохами двух последовательных обновлений максимума критерия обучения;
• разница между значениями критерия обучения при двух последних обновлениях его максимума;
• число обновлений максимума критерия обучения.

Эти значения можно находить как для потенциально лучших решений по заданному критерия обучения, так и для выбранного решения.
Поиск выполняется в случае критерия val_acc или acc по истории обучения, отвечающей текущему решению. В случае критерия corr_img предварительно создается список, содержащий значения критерия для текущего решения.
Сведения о наибольших расстояниях между эпохами двух последовательных обновлений максимума критерия обучения для различных наборов данных и критериев обучения приведены в табл. 18.

Таблица 18. Наибольшие расстояния между эпохами двух последовательных обновлений максимума критерия обучения

Сведения о наибольшей разнице между двумя последними обновлениями максимума критерия обучения для различных наборов данных и критериев обучения приведены в табл. 19.

Таблица 19. Наибольшие разницы между двумя последними обновлениями максимума критерия обучения

Замечание. В случае corr_img выводится err_img = all_img – corr_img, где all_img – число изображений в наборе данных.

Число обновлений максимума критерия обучения определяется для потенциально лучших решений выбранной модели НС. Эта характеристика для модели c14 и критерия val_acc приведена в табл. 20.

Таблица 20. Число обновлений максимума val_acc при обучении модели c14

На рис. 19 показана диаграмма максимальных расстояний между эпохами двух последовательных обновления максимума критерия acc при обучении разных моделей на MNIST с функцией kld (как и ранее берутся потенциально лучшие решения).

Рис. 19. Максимальные расстояния между эпохами обновления максимума критерия acc (MNIST, лучшие решения)

На рис. 20 приведена диаграмма максимальных разниц значений критерия acc двух последовательных обновления его максимума при обучении разных моделей на MNIST с функцией kld (как и ранее берутся потенциально лучшие решения).

Рис. 20. Разница между значениями критерия acc при последних обновлениях его максимума (MNIST, лучшие решения)

На рис. 21 приведены диаграммы числа обновлений максимума критерия val_acc, построенные по табл. 14.

Рис. 21. Число обновлений максимума критерия val_acc

Приведенные результаты позволяет получить процедура find_history_values программы обработки историй обучения.

Модели НС с близкими списками эффективных функций потерь

Такие модели выявляются по историям обучения после задания набора данных, критерия обучения и коэффициента близости списков эффективных функций потерь
Порядок обработки данных по следующей схеме:

1. Для каждой модели по историям ее обучения формируется список эффективных функции потерь – функций, обеспечивающих потенциально лучшие решения.
2. Для каждой пары моделей НС выполняется сравнение их списков эффективных функции потерь. Если списки близки, то выводятся имена моделей, списки эффективных функций, обозначения моделей и число параметров в модели.

Два списка считаются близкими, если число n_eq одинаковых функций потерь в этих списках удовлетворяет следующему условию:

n_eq >= near * (len1 + len2) / 2,

где near – коэффициент близости списков;
len1, len2 – длины списков.

Результаты для различных наборов данных с критерием обучения err_img – число ошибочно классифицированных изображений:

MNIST. Всего моделей: 19. near = 0.85:
1
['w_6', 'w_4']
[['cce', 'ck', 'kld']]
[['cce', 'ck', 'kld']]
CR20-P-CR30-P-F-DR600 / 898'580
CR20-P-CR30-P-F-DR600-DL30 / 910'910
2
['w_9', 'w_1']
[['kld', 'pss', 'scce']]
[['kld', 'pss', 'scce']]
CR20-P-CR30-P-F-DR600-DL16 / 902'356
CR32-P-CR64-P-F-0.35-DR1024-0.2-DL30 / 3'276'724
3
['w_12', 'w_17']
[['cce']]
[['cce']]
CR20-P-CR30-P-F-0.25-DR600-0.2-DL16 / 902'356
CR32-P-CR64-P-F-0.25-DR800-DL30 / 2'567'316
4
['2w_12', '3w_12']
[['cp', 'mse']]
[['cp', 'mse']]
CR20-P-CR30-P-F-0.25-DR600-0.2-DL16 / 902'356 * 2
CR20-P-CR30-P-F-0.25-DR600-0.2-DL16 / 902'356 * 3
Список моделей, не имеющих моделей с близким списком эффективных функций потерь:
['w_5', 'w_7', 'w_8', 'w_11', '2w_12_2', 'w_13', 'w_14', 'w_10', 'w_15', 'w_16', 'w_18']
Длина списка: 11
Всего моделей: 19

EMNIST. Всего моделей: 30. near = 0.85:
1
['w_19', 'w_28']
[['kld', 'mk', 'scce']]
[['kld', 'mk', 'scce']]
CR10-P-CR15-P-F-0.25-DR300 / 231'211
CR20-P-CR30-P-F-0.3-DR600-0.2-DL60-0.2 / 930'216
2
['w_9', 'w_24']
[['ck', 'mk', 'pss', 'scce']]
[['cce', 'ck', 'mk', 'pss', 'scce']]
CR20-P-CR30-P-F-DR600-DL16 / 902'628
CR20-P-CR30-P-F-0.3-DR600-0.2-DL52-0.2 / 949'026
3
['w_12', 'w_1']
[['mk']]
[['mk']]
CR20-P-CR30-P-F-0.25-DR600-0.2-DL16 / 902'628
CR32-P-CR64-P-F-0.35-DR1024-0.2-DL30 / 3'277'220
4
['2w_12', '3w_12']
[['cp', 'msle']]
[['cp', 'msle']]
CR20-P-CR30-P-F-0.25-DR600-0.2-DL16 / 902'628 * 2
CR20-P-CR30-P-F-0.25-DR600-0.2-DL16 / 902'628 * 3
5
['w_13', 'w_14']
[['cce', 'ck', 'kld', 'mk', 'pss', 'scce']]
[['cce', 'ck', 'kld', 'mk', 'pss', 'scce']]
CR20-P-CR30-P-F-0.25-DR600-DL30 / 911'406
CR20-P-CR30-P-F-0.25-DR600-0.2-DL30 / 911'406
6
['w_13', 'w_24']
[['cce', 'ck', 'kld', 'mk', 'pss', 'scce']]
[['cce', 'ck', 'mk', 'pss', 'scce']]
CR20-P-CR30-P-F-0.25-DR600-DL30 / 911'406
CR20-P-CR30-P-F-0.3-DR600-0.2-DL52-0.2 / 949'026
7
['w_13', 'w_26']
[['cce', 'ck', 'kld', 'mk', 'pss', 'scce']]
[['cce', 'ck', 'kld', 'mk', 'pss', 'scce']]
CR20-P-CR30-P-F-0.25-DR600-DL30 / 911'406
CR20-P-CR30-P-F-0.3-DR600-DL60 / 930'216
8
['w_13', 'w_15']
[['cce', 'ck', 'kld', 'mk', 'pss', 'scce']]
[['cce', 'ck', 'kld', 'pss', 'scce']]
CR20-P-CR30-P-F-0.25-DR600-DL30 / 911'406
CR32-P-CR64-P-F-0.25-DR800-DL16 / 2'556'234
9
['w_14', 'w_24']
[['cce', 'ck', 'kld', 'mk', 'pss', 'scce']]
[['cce', 'ck', 'mk', 'pss', 'scce']]
CR20-P-CR30-P-F-0.25-DR600-0.2-DL30 / 911'406
CR20-P-CR30-P-F-0.3-DR600-0.2-DL52-0.2 / 949'026
10
['w_14', 'w_26']
[['cce', 'ck', 'kld', 'mk', 'pss', 'scce']]
[['cce', 'ck', 'kld', 'mk', 'pss', 'scce']]
CR20-P-CR30-P-F-0.25-DR600-0.2-DL30 / 911'406
CR20-P-CR30-P-F-0.3-DR600-DL60 / 930'216
11
['w_14', 'w_15']
[['cce', 'ck', 'kld', 'mk', 'pss', 'scce']]
[['cce', 'ck', 'kld', 'pss', 'scce']]
CR20-P-CR30-P-F-0.25-DR600-0.2-DL30 / 911'406
CR32-P-CR64-P-F-0.25-DR800-DL16 / 2'556'234
12
['w_24', 'w_26']
[['cce', 'ck', 'mk', 'pss', 'scce']]
[['cce', 'ck', 'kld', 'mk', 'pss', 'scce']]
CR20-P-CR30-P-F-0.3-DR600-0.2-DL52-0.2 / 949'026
CR20-P-CR30-P-F-0.3-DR600-DL60 / 930'216
13
['w_26', 'w_15']
[['cce', 'ck', 'kld', 'mk', 'pss', 'scce']]
[['cce', 'ck', 'kld', 'pss', 'scce']]
CR20-P-CR30-P-F-0.3-DR600-DL60 / 930'216
CR32-P-CR64-P-F-0.25-DR800-DL16 / 2'556'234
14
['w_27', 'w_02']
[['ck', 'mk']]
[['ck', 'mk']]
CR20-P-CR30-P-F-0.3-DR600-0.2-DL60 / 930'216
CR32-P-CR64-P-F-0.35-DR1024-0.2-DL16 / 3'262'506
15
['2w_24', '2w_27']
[['cp']]
[['cp']]
CR20-P-CR30-P-F-0.3-DR600-0.2-DL52-0.2 / 949'026 * 2
CR20-P-CR30-P-F-0.3-DR600-0.2-DL60 / 930'216 * 2
16
['2w_24', '2w_28']
[['cp']]
[['cp']]
CR20-P-CR30-P-F-0.3-DR600-0.2-DL52-0.2 / 949'026 * 2
CR20-P-CR30-P-F-0.3-DR600-0.2-DL60-0.2 / 930'216 * 2
17
['2w_24', '2w_28_2']
[['cp']]
[['cp']]
CR20-P-CR30-P-F-0.3-DR600-0.2-DL52-0.2 / 949'026 * 2
CR20-P-CR30-P-F-0.3-DR600-0.2-DL60-0.2 / 930'216 * 2
18
['2w_27', '2w_28']
[['cp']]
[['cp']]
CR20-P-CR30-P-F-0.3-DR600-0.2-DL60 / 930'216 * 2
CR20-P-CR30-P-F-0.3-DR600-0.2-DL60-0.2 / 930'216 * 2
19
['2w_27', '2w_28_2']
[['cp']]
[['cp']]
CR20-P-CR30-P-F-0.3-DR600-0.2-DL60 / 930'216 * 2
CR20-P-CR30-P-F-0.3-DR600-0.2-DL60-0.2 / 930'216 * 2
20
['2w_28', '2w_28_2']
[['cp']]
[['cp']]
CR20-P-CR30-P-F-0.3-DR600-0.2-DL60-0.2 / 930'216 * 2
CR20-P-CR30-P-F-0.3-DR600-0.2-DL60-0.2 / 930'216 * 2
Список моделей, не имеющих моделей с близким списком эффективных функций потерь:
['w_5', 'w_7', 'w_20', '2w_20', '3w_20', 'w_21', 'w_11', 'w_4', 'w_10', 'w_25', 'w_17', 'w_3']
Длина списка: 12
Всего моделей: 30

CIFAR-10. Всего моделей: 15. near = 0.95:
1
['w_4', 'w_13']
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
CR20-P-CR30-P-F-DR600-DL30 / 1'176'930
CR20-P-CR30-P-F-0.25-DR600-DL30 / 1'176'930
2
['w_4', 'w_14']
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
CR20-P-CR30-P-F-DR600-DL30 / 1'176'930
CR20-P-CR30-P-F-0.25-DR600-0.2-DL30 / 1'176'930
3
['w_4', '2w_14']
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
CR20-P-CR30-P-F-DR600-DL30 / 1'176'930
CR20-P-CR30-P-F-0.25-DR600-0.2-DL30 / 1'176'930 * 2
4
['w_4', '3w_14']
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
CR20-P-CR30-P-F-DR600-DL30 / 1'176'930
CR20-P-CR30-P-F-0.25-DR600-0.2-DL30 / 1'176'930 * 3
5
['w_13', 'w_14']
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
CR20-P-CR30-P-F-0.25-DR600-DL30 / 1'176'930
CR20-P-CR30-P-F-0.25-DR600-0.2-DL30 / 1'176'930
6
['w_13', '2w_14']
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
CR20-P-CR30-P-F-0.25-DR600-DL30 / 1'176'930
CR20-P-CR30-P-F-0.25-DR600-0.2-DL30 / 1'176'930 * 2
7
['w_13', '3w_14']
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
CR20-P-CR30-P-F-0.25-DR600-DL30 / 1'176'930
CR20-P-CR30-P-F-0.25-DR600-0.2-DL30 / 1'176'930 * 3
8
['w_14', '2w_14']
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
CR20-P-CR30-P-F-0.25-DR600-0.2-DL30 / 1'176'930
CR20-P-CR30-P-F-0.25-DR600-0.2-DL30 / 1'176'930 * 2
9
['w_14', '3w_14']
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
CR20-P-CR30-P-F-0.25-DR600-0.2-DL30 / 1'176'930
CR20-P-CR30-P-F-0.25-DR600-0.2-DL30 / 1'176'930 * 3
10
['2w_14', '3w_14']
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
[['bce', 'cce', 'ck', 'cp', 'kld', 'lc', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
CR20-P-CR30-P-F-0.25-DR600-0.2-DL30 / 1'176'930 * 2
CR20-P-CR30-P-F-0.25-DR600-0.2-DL30 / 1'176'930 * 3
11
['w_17', 'w_18']
[['bce', 'cce', 'ch', 'ck', 'cp', 'h', 'kld', 'lc', 'mae', 'mape', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
[['bce', 'cce', 'ck', 'cp', 'h', 'kld', 'lc', 'mae', 'mape', 'mk', 'mse', 'msle', 'pss', 'scce', 'sh']]
CR32-P-CR64-P-F-0.25-DR800-DL30 / 3'321'332
CR32-P-CR64-P-F-0.25-DR800-0.2-DL30 / 3'321'332
Список моделей, не имеющих моделей с близким списком эффективных функций потерь:
['w_5', 'w_7', 'w_15', 'w_16', 'w_33', 'w_34', 'w_1', 'res_net']
Длина списка: 8
Всего моделей: 15

Пересечение списков неверно классифицированных изображений на тестовых данных

Пересечение списков неверно классифицированных изображений выполняется на тестовой выборке.
Эта операция позволяет, во-первых, установить, какие изображения не смогла верно классифицировать ни одна из примененных моделей НС, во-вторых, выделить трудно классифицируемые изображения, а в-третьих, оценить предельно достижимую точность классификацию тестовых изображений рассматриваемого набора данных.
По аналогии с множествами пересечение списков A и B – это список, содержащий элементы, имеющиеся и в A и в B.
Список неверно классифицированных изображений получается в следующей последовательности:

1. Выбрать модели НС с наилучшими значениями точности классификации.
2. После обучения на этапе тестирования для выбранных модели НС в текстовые файлы выгрузить списки номеров неверно классифицированных изображений.
3. В отдельной программе эти файлы загрузить в списки и найти пересечение этих списков.

В случае MNIST были выбраны следующие решения:

• 2c12(cce_kld_scce, val_acc = 99.62);
• 2c12(scce, val_acc = 99.61);
• 2c12(mse, val_acc = 99.60);
• 2c12(cce_kld, val_acc = 99.58);
• 2c12(msle, val_acc = 99.57);
• c13(cce, val_acc = 99.54);
• c13(mse, val_acc = 99.53);
• c11(mae, val_acc = 99.51);
• 2c12(h, val_acc = 99.50);
• c11(bce, val_acc = 99.50);
• c11(pss, val_acc = 99.50);
• c11(sh, val_acc = 99.50);
• c11(msle, val_acc = 99.49);
• c11(mape, val_acc = 99.48).

В случае EMNIST пересечение 69 списков с индексами неверно классифицированных изображений на тестовой выборке различными моделями НС с критерием val_acc в диапазоне [95.03 – 94.7] дает список длинной 342.

Замечание. При val_acc = 95.03 неверно классифицируются 1034 изображения тестовой выборки, а при val_acc = 94.7 – 1102 изображения.

Код, обеспечивающий выгрузку в файл err_pics.txt индексов неверно классифицированных изображений MNIST или EMNIST:

def saveErrPics(model, X_test, y_test, y_test_0):
    # model - модель НС
    # X_test - массив тестовых данных
    # y_test_0 - массив меток (номеров классов) меток тестовых данных
    # y_test - массив с категориальным представлением меток тестовых данных
    file_name = 'err_pics.txt'
    n_test = len(y_test)
    y_pred = model.predict(X_test) # Прогнозирование
    classes = []
    for m in y_pred:
        classes.append(np.argmax(m))
    # np.sum(classes == y_test_0) вернет сумму случаев, когда classes[i] = y_test_0[i]
    nClassified = np.sum(classes == y_test_0)
    nNotClassified = n_test - nClassified # Число неверно классифицированных образов
    fp = open(file_name, 'w')
    n = 0
    for i in range(n_test):
        s_true = names[y_test_0[i]]
        s_pred = names[classes[i]]
        if s_true != s_pred:
            n += 1
            if (n > nNotClassified): break
            fp.write(str(i) + '\n')
    fp.close()

Код, выполняющий загрузку файлов со списками индексов неверно классифицированных образов и находящий пересечение этих списков:

p0 = 'G:/AM/НС/errPics/'
printErr = False
nnTypeNum = 1 # 1 - conv; 2 - mlp; 3 - lstm
dataSetNum = 1 # 1 - MNIST; 2 - EMNIST; 3 - CIFAR10
#
# Пересечение списков неверно классифицированных изображений
def loadErr(fn):
    with open(pathToErrData + fn, 'r') as f:
        err = f.read()
    err = err.split('\n')
    if err.index('') > 0: err.remove('')
    return err
#
def crossErr(err, err2):
    errPics = []
    for s in err:
        if len(s) > 0 and s in err2:
            errPics.append(s)
    return errPics
nf = 69
if nnTypeNum == 1:
    if dataSetNum == 1:
        pathToErrData = p0 + 'mnist/'
        fn1 = 'err_MNIST_cce_kld_scce_Adam_2c12_38' + '.txt'
        fn2 = 'err_MNIST_scce_Adam_2c12_39' + '.txt'
        fn3 = 'err_MNIST_mse_Adam_2c12_40' + '.txt'
        fn4 = 'err_MNIST_cce_kld_Adam_2c12_42' + '.txt'
        fn5 = 'err_MNIST_msle_Adam_2c12_43' + '.txt'
        fn6 = 'err_MNIST_cce_Adam_c13_46' + '.txt'
        fn7 = 'err_MNIST_mse_Adam_c13_47' + '.txt'
        fn8 = 'err_MNIST_mae_Adam_c11_49' + '.txt'
        fn9 = 'err_MNIST_h_Adam_2c12_50' + '.txt'
        fn10 = 'err_MNIST_bce_Adam_c11_50' + '.txt'
        fn11 = 'err_MNIST_pss_Adam_c11_50' + '.txt'
        fn12 = 'err_MNIST_sh_Adam_c11_50' + '.txt'
        fn13 = 'err_MNIST_msle_Adam_c11_51' + '.txt'
        fn14 = 'err_MNIST_mape_Adam_c11_52' + '.txt'
    else:
        pathToErrData = p0 + 'emnist/'
        fn1 = 'err_EMNIST_lc_Adam_2c28_1033' + '.txt'
        fn2 = 'err_EMNIST_mse_Adam_2c27_1051' + '.txt'
        fn3 = 'err_EMNIST_lc_Adam_2c28_2_1052' + '.txt'
        fn4 = 'err_EMNIST_pss_Adam_2c28_2_1057' + '.txt'
        fn5 = 'err_EMNIST_mse17_kld_Adam_2c24_1057' + '.txt'
        fn6 = 'err_EMNIST_mse_Adam_2c28_1058' + '.txt'
        fn7 = 'err_EMNIST_msle_Adam_2c24_1059' + '.txt'
        fn8 = 'err_EMNIST_msle_Adam_2c28_2_1059' + '.txt'
        fn9 = 'err_EMNIST_msle_Adam_2c28_1060' + '.txt'
        fn10 = 'err_EMNIST_pss_Adam_2c28_1063' + '.txt'
        fn11 = 'err_EMNIST_lc_Adam_2c27_1064' + '.txt'
        fn12 = 'err_EMNIST_sh_Adam_2c24_1066' + '.txt'
        fn13 = 'err_EMNIST_cp_Adam_2c28_1066' + '.txt'
        fn14 = 'err_EMNIST_cce_kld_Adam_2c28_2_1067' + '.txt'
        fn15 = 'err_EMNIST_bce_Adam_2c28_1068' + '.txt'
        fn16 = 'err_EMNIST_cce_Adam_2c28_1068' + '.txt'
        fn17 = 'err_EMNIST_cce_kld_Adam_2c28_1069' + '.txt'
        fn18 = 'err_EMNIST_sh_Adam_2c28_2_1069' + '.txt'
        fn19 = 'err_EMNIST_cce_Adam_2c27_1070' + '.txt'
        fn20 = 'err_EMNIST_mse_Adam_2c28_2_1070' + '.txt'
        fn21 = 'err_EMNIST_pss_Adam_2c24_1071' + '.txt'
        fn22 = 'err_EMNIST_bce_Adam_2c24_1072' + '.txt'
        fn23 = 'err_EMNIST_mse_Adam_c28_1072' + '.txt'
        fn24 = 'err_EMNIST_msle_Adam_2c27_1072' + '.txt'
        fn25 = 'err_EMNIST_cce_kld_Adam_2c24_1073' + '.txt'
        fn26 = 'err_EMNIST_lc_Adam_2c24_1073' + '.txt'
        fn27 = 'err_EMNIST_kld_Adam_2c24_1075' + '.txt'
        fn28 = 'err_EMNIST_cp_Adam_2c24_1076' + '.txt'
        fn29 = 'err_EMNIST_sh_Adam_2c28_1076' + '.txt'
        fn30 = 'err_EMNIST_mse_Adam_2c24_1076' + '.txt'
        fn31 = 'err_EMNIST_msle_Adam_c24_1077' + '.txt'
        fn32 = 'err_EMNIST_cce_Adam_2c24_1078' + '.txt'
        fn33 = 'err_EMNIST_bce_Adam_2c27_1077' + '.txt'
        fn34 = 'err_EMNIST_cp_Adam_2c28_1077' + '.txt'
        fn35 = 'err_EMNIST_sh_Adam_2c27_1080' + '.txt'
        fn36 = 'err_EMNIST_scce_Adam_2c27_1079' + '.txt'
        fn37 = 'err_EMNIST_scce_Adam_2c28_1080' + '.txt'
        fn38 = 'err_EMNIST_kld_Adam_2c28_2_1080' + '.txt'
        fn39 = 'err_EMNIST_mse17_kld_Adam_2c27_1079' + '.txt'
        fn40 = 'err_EMNIST_bce_Adam_2c28_1082' + '.txt'
        fn41 = 'err_EMNIST_pss_Adam_2c27_1083' + '.txt'
        fn42 = 'err_EMNIST_sh_Adam_2c12_1083' + '.txt'
        fn43 = 'err_EMNIST_bce_Adam_c24_1084' + '.txt'
        fn44 = 'err_EMNIST_cce_Adam_2c12_1090' + '.txt'
        fn45 = 'err_EMNIST_mse17_kld_Adam_c24_1089' + '.txt'
        fn46 = 'err_EMNIST_sh_Adam_3c12_1091' + '.txt'
        fn47 = 'err_EMNIST_kld_Adam_c24_1092' + '.txt'
        fn48 = 'err_EMNIST_mse_Adam_c3_1093' + '.txt'
        fn49 = 'err_EMNIST_cp_Adam_2c28_1075_old' + '.txt'
        fn50 = 'err_EMNIST_bce_Adam_2c27_1080_old' + '.txt'
        fn51 = 'err_EMNIST_sh_Adam_3c12_1086_old' + '.txt'
        fn52 = 'err_EMNIST_cce_kld_Adam_3c12_1085_old' + '.txt'
        fn53 = 'err_EMNIST_cce_kld_Adam_2c12_1095_old' + '.txt'
        fn54 = 'err_EMNIST_mse_Adam_2c12_1096' + '.txt'
        fn55 = 'err_EMNIST_lc_Adam_c28_1096' + '.txt'
        fn56 = 'err_EMNIST_kld_Adam_c28_1096' + '.txt'
        fn57 = 'err_EMNIST_pss_Adam_2c28_1096_old' + '.txt'
        fn58 = 'err_EMNIST_kld_Adam_c28_1096' + '.txt'
        fn59 = 'err_EMNIST_cp_Adam_3c20_1097' + '.txt'
        fn60 = 'err_EMNIST_lc_Adam_c27_1098' + '.txt'
        fn61 = 'err_EMNIST_msle_Adam_3c20_1098' + '.txt'
        fn62 = 'err_EMNIST_myLoss_Adam_2c12_1098' + '.txt'
        fn63 = 'err_EMNIST_lc_Adam_2c12_1099' + '.txt'
        fn64 = 'err_EMNIST_cce_kld_Adam_3c12_1099' + '.txt'
        fn65 = 'err_EMNIST_cce_kld_Adam_2c12_1100' + '.txt'
        fn66 = 'err_EMNIST_lc_Adam_3c20_1101' + '.txt'
        fn67 = 'err_EMNIST_bce_Adam_3c12_1101' + '.txt'
        fn68 = 'err_EMNIST_mse_Adam_3c12_1102' + '.txt'
        fn69 = 'err_EMNIST_cp_Adam_3c20_1103' + '.txt'
elif nnTypeNum == 2:
    pathToErrData = p0 + 'mnist_mlp/'
    fn1 = 'err_MNIST_cce_kld_Adam_mlp_3' + '.txt'
    fn2 = 'err_MNIST_pss_Adam_mlp_3' + '.txt'
    fn3 = 'err_MNIST_bce_Adam_mlp_3' + '.txt'
    fn4 = 'err_MNIST_kld_Adam_mlp_3' + '.txt'
    fn5 = 'err_MNIST_bce_Adam_mlp_1' + '.txt'
    fn6 = 'err_MNIST_cce_kld_Adam_mlp_1' + '.txt'
    fn7 = 'err_MNIST_bce_Adam_mlp_2' + '.txt'
    fn8 = 'err_MNIST_myLoss_Adam_mlp_1' + '.txt'
    fn9 = '' + '.txt'
if dataSetNum == 1:
    lst_fn = [fn1, fn2, fn3, fn4, fn5, fn6, fn7, fn8, fn9, fn10,
             fn11, fn12, fn13, fn14]
else:
    lst_fn = [fn1, fn2, fn3, fn4, fn5, fn6, fn7, fn8, fn9, fn10,
             fn11, fn12, fn13, fn14, fn15, fn16, fn17, fn18, fn19, fn20,
             fn21, fn22, fn23, fn24, fn25, fn26, fn27, fn28, fn29, fn30,
             fn31, fn32, fn33, fn34, fn35, fn36, fn37, fn38, fn39, fn40,
             fn41, fn42, fn43, fn44, fn45, fn46, fn47, fn48, fn49, fn50,
             fn51, fn52, fn53, fn54, fn55, fn56, fn57, fn58, fn59, fn60,
             fn61, fn62, fn63, fn64, fn65, fn66, fn67, fn68, fn69]
nf = min(len(lst_fn), nf)
err1 = loadErr(fn1)
err2 = loadErr(fn2)
if printErr: print(err1)
if printErr: print(err2)
errPics = crossErr(err1, err2)
print('Число изображений в ' + fn1 + ':', len(err1))
print('Число изображений в ' + fn2 + ':', len(err2))
print('Будет выполнено пересечений:', nf)
print('Номер пересечения: 1')
print('Всего неверных классификаций', len(errPics))
for m in range(2, nf):
    fn = lst_fn[m]
    err = loadErr(fn)
    print('Число изображений в ' + fn + ':', len(err))
    if printErr: print(err)
    errPics = crossErr(errPics, err);
    print('Номер пересечения:', m)
    print('Всего неверных классификаций', len(errPics))
print('Список неверных классификаций:')
print(errPics)

Результат поиска пересечений в случае MNIST:

Число изображений в err_MNIST_cce_kld_scce_Adam_2c12_38.txt: 38
Число изображений в err_MNIST_scce_Adam_2c12_39.txt: 39
Номер пересечения: 1
Всего неверных классификаций 29
Число изображений в err_MNIST_mse_Adam_2c12_40.txt: 40
Номер пересечения: 2
Всего неверных классификаций 23
Число изображений в err_MNIST_cce_kld_Adam_2c12_42.txt: 42
Номер пересечения: 3
Всего неверных классификаций 20
Число изображений в err_MNIST_msle_Adam_2c12_43.txt: 43
Номер пересечения: 4
Всего неверных классификаций 19
Число изображений в err_MNIST_cce_Adam_c13_46.txt: 46
Номер пересечения: 5
Всего неверных классификаций 14
Число изображений в err_MNIST_mse_Adam_c13_47.txt: 47
Номер пересечения: 6
Всего неверных классификаций 11
Число изображений в err_MNIST_mae_Adam_c11_49.txt: 49
Номер пересечения: 7
Всего неверных классификаций 9
Число изображений в err_MNIST_h_Adam_2c12_50.txt: 50
Номер пересечения: 8
Всего неверных классификаций 7
Число изображений в err_MNIST_bce_Adam_c11_50.txt: 50
Номер пересечения: 9
Всего неверных классификаций 6
Число изображений в err_MNIST_pss_Adam_c11_50.txt: 50
Номер пересечения: 10
Всего неверных классификаций 4
Число изображений в err_MNIST_sh_Adam_c11_50.txt: 50
Номер пересечения: 11
Всего неверных классификаций 4
Число изображений в err_MNIST_msle_Adam_c11_51.txt: 51
Номер пересечения: 12
Всего неверных классификаций 2
Число изображений в err_MNIST_mape_Adam_c11_52.txt: 52
Номер пересечения: 13
Всего неверных классификаций 2
Список неверных классификаций:
['1014', '1901']

Вывод неверно классифицированных изображений обеспечивает следующий код:

import numpy as np
import matplotlib.pyplot as plt
#
errPics = [1014, 1901]
dataSetNum = 1 # 1 - MNIST; 2 - EMNIST
#
def makeNames(imgType):
    names = []
    if imgType == 'MNIST':
        for i in range(10): names.append(chr(48 + i)) # ['0', '1', '2', ..., '9']
    elif imgType == 'EMNIST':
        for i in range(26): names.append(chr(65 + i)) # ['A', 'B', 'C', ..., 'Z']
    return names
def load_test(pathToData):
    with open(pathToData + 'imagesTest.bin', 'rb') as read_binary:
        data2 = np.fromfile(read_binary, dtype = np.uint8)
    with open(pathToData + 'labelsTest.bin', 'rb') as read_binary:
        labels2 = np.fromfile(read_binary, dtype = np.uint8)
    X_test = np.asarray(data2)
    y_test = np.asarray(labels2)
    return X_test, y_test, len(y_test)
#
# Путь к тестовым данным
p0 = 'G:/AM/НС/'
if dataSetNum == 1:
    pathToData = p0 + 'mnist/'; imgType = 'MNIST'
elif dataSetNum == 2:
    pathToData = p0 + 'emnist/'; imgType = 'EMNIST'
else: print('Плохой номер набора данных'); sys.exit()
#
X_test, y_test_0, n_test = load_test(pathToData)
if imgType == 'MNIST':
    X_test = X_test.reshape(n_test, 28, 28, 1)
elif imgType == 'EMNIST':
    X_test = X_test.reshape(n_test, 28, 28, 1).transpose(0,2,1,3)
    y_test_0 -= 1
names = makeNames(imgType)
n = 0
for m in errPics:
    n += 1
    s_true = names[y_test_0[m]]
    plt.subplot(1, 8, n)
    plt.imshow(X_test[m].reshape(28, 28), cmap = plt.get_cmap('gray'))
    plt.title(s_true)
    plt.axis('off')
plt.subplots_adjust(hspace = 0.5)
plt.show()

Изображения цифр 6 и 9 тестового набора данных MNIST, которые не смогли верно классифицировать примененные модели НС, показаны на рис. 22.

Рис. 22. Изображения тестового набора данных MNIST, которые не смогли верно классифицировать примененные модели НС
Индексы изображений в массиве меток: 1014, 1901

Над изображением его истинная метка, снизу – метка, предсказанная c11(mae).
Другие модели НС могут давать иные прогнозы. Так, c01(bce) для изображения с индексом 1014 предсказала 0 вместо 6.

Примеры букв из EMNIST, ошибочно классифицируемых всеми моделями НС, показаны на рис. 23.

Рис. 23. Примеры изображений тестового набора данных EMNIST, которые не смогли верно классифицировать примененные модели НС

Объединение прогнозов

Изображения, которые не смогли верно классифицировать использованные НС, можно получить, если объединить прогнозы нескольких НС с различными функциями потерь и использовать этот объединенный прогноз для классификации изображения.
Возьмем, к примеру, прогнозы y_pred_1 и y_pred_2 СНС c11(mae) и c11(sh).
Объединение прогнозов y_pred_1 и y_pred_2 осуществляется по следующему правилу:

Если y_pred_1 != y_test и y_pred_2 = y_test Тогда
    y_pred = y_pred_2
Иначе
    y_pred = y_pred_1

В приведенном выше правиле y_test – это метка изображения (истинное значение класса изображения).
Так, если взять по три первых прогноза каждой из названных выше СНС:

Прогнозы из y_pred_MNIST_mae_Adam_conv_11.bin:

[0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00
0.0000000e+00 0.0000000e+00 1.0000000e+00 0.0000000e+00 0.0000000e+00]
[0.0000000e+00 0.0000000e+00 1.0000000e+00 0.0000000e+00 0.0000000e+00
0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00]
[5.5263964e-33 1.0000000e+00 2.4369681e-30 0.0000000e+00 5.4157616e-27
7.3043492e-34 1.3921112e-31 8.2266358e-28 3.2682385e-35 0.0000000e+00]

Прогнозы из y_pred_MNIST_sh_Adam_conv_11.bin:

[2.3635973e-28 7.1891472e-22 1.6735443e-27 3.3039484e-22 1.3014925e-30
7.5735469e-31 1.1090597e-36 1.0000000e+00 2.0680592e-33 1.0226212e-23]
[5.9359326e-24 1.6917469e-28 1.0000000e+00 0.0000000e+00 1.3270321e-35
0.0000000e+00 3.1075434e-27 2.4121234e-32 2.1794855e-34 9.4866112e-38]
[1.2166917e-17 1.0000000e+00 3.1378157e-17 6.6714030e-24 1.6553219e-12
2.2798540e-16 7.6239186e-18 2.4329525e-10 1.4236543e-20 5.9331766e-22]

Получим следующие итоговые прогнозы:

[0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00
0.0000000e+00 0.0000000e+00 1.0000000e+00 0.0000000e+00 0.0000000e+00]
[0.0000000e+00 0.0000000e+00 1.0000000e+00 0.0000000e+00 0.0000000e+00
0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00]
[5.5263964e-33 1.0000000e+00 2.4369681e-30 0.0000000e+00 5.4157616e-27
7.3043492e-34 1.3921112e-31 8.2266358e-28 3.2682385e-35 0.0000000e+00]

В результате использования объединенного прогноза моделей c11(mae + sh) точно классифицируются 99.75%.
Если использовать объединенный прогноз:

c11(mae + sh + pss + bce + msle + mape +mse + lc) + c4(msle) + c6(lc),

то на тестовой выборке MNIST точно классифицируются 99.98%. Неверно классифицированные изображения показаны на рис. 24, который, конечно же, совпадают с изображениями рис. 22.

Рис. 24. Изображения тестового набора данных MNIST, неверно классифицируемые объединенным прогнозом
модели c11(mae + sh + pss + bce + msle + mape +mse + lc) + c4(msle) + c6(lc)

На рис. 24 над каждой цифрой указаны истинное и предсказанные значения.
Индексы изображений в массиве тестовых образов:

1. i = 1014. На самом деле: 6. Прогноз: 5
2. i = 1901. На самом деле: 9. Прогноз: 4

Сохранение в бинарный файл прогнозов выбранной НС обеспечивает следующий код:

def writeToBin(file_name, y, txt):
    fp = open(file_name, 'wb')
    fp.write(y)
    fp.close()
    print(txt + file_name)
#
...
    y_pred = model.predict(X_test) # Предсказания модели НС на тестовой выборке
    writeToBin(pathToData + 'y_pred.bin', y_pred, 'Прогноз сохранен в файле ')

Чтение бинарных файлов с прогнозами различных НС, формирование объединенного прогноза и оценка его истинности обеспечивается следующим кодом:

import numpy as np
import matplotlib.pyplot as plt
#
pathToErrData = 'G:/AM/НС/y_pred/'
dataSetNum = 1 # 1 - MNIST; 2 - EMNIST
showErrPics = True # True False
fn1 = 'y_pred_MNIST_mae_Adam_conv_11' + '.bin'
fn2 = 'y_pred_MNIST_sh_Adam_conv_11' + '.bin'
fn3 = 'y_pred_MNIST_pss_Adam_conv_11' + '.bin'
fn4 = 'y_pred_MNIST_bce_Adam_conv_11' + '.bin'
fn5 = 'y_pred_MNIST_msle_Adam_conv_11' + '.bin'
fn6 = 'y_pred_MNIST_mape_Adam_conv_11' + '.bin'
fn7 = 'y_pred_MNIST_mse_Adam_conv_11' + '.bin'
fn8 = 'y_pred_MNIST_lc_Adam_conv_11' + '.bin'
fn9 = 'y_pred_MNIST_msle_conv_4' + '.bin'
fn10 = 'y_pred_MNIST_lc_conv_6' + '.bin'
lst_fn = [fn1, fn2, fn3, fn4, fn5, fn6, fn7, fn8, fn9, fn10]
nf = len(lst_fn)
#
def load_y_pred(fn, num_classes):
    with open(pathToErrData + fn, 'rb') as f:
        y_p = np.fromfile(f, dtype = np.float32)
    n = int(len(y_p) / num_classes)
    y_pred = []
    m = -1
    for i in range(n):
        one_y = []
        for j in range(num_classes):
            m += 1
            one_y.append(y_p[m])
        y_pred.append(one_y)
    return np.asarray(y_pred)
def make_y_pred(n_test, y_test_0, y_pred, fn, num_classes):
    y2 = load_y_pred(fn, num_classes)
    print('Прогнозы из ' + fn + ':')
    print(y2[0:3])
    cl = []
    for m in y_pred:
        cl.append(np.argmax(m))
    cl2 = []
    for m in y2:
        cl2.append(np.argmax(m))
    for k in range(n_test):
        c = y_test_0[k]
        if cl[k] != c and cl2[k] == c: y_pred[k] = y2[k]
    return y_pred
def makeNames(imgType):
    names = []
    if imgType == 'MNIST':
        for i in range(10): names.append(chr(48 + i)) # ['0', '1', '2', ..., '9']
    elif imgType == 'EMNIST':
        for i in range(26): names.append(chr(65 + i)) # ['A', 'B', 'C', ..., 'Z']
    return names
def load_test(pathToData):
    with open(pathToData + 'imagesTest.bin', 'rb') as read_binary:
        data2 = np.fromfile(read_binary, dtype = np.uint8)
    with open(pathToData + 'labelsTest.bin', 'rb') as read_binary:
        labels2 = np.fromfile(read_binary, dtype = np.uint8)
    X_test = np.asarray(data2)
    y_test = np.asarray(labels2)
    return X_test, y_test, len(y_test)
#
# Путь к тестовым данным
p0 = 'G:/AM/НС/'
if dataSetNum == 1:
    pathToData = p0 + 'mnist/'; imgType = 'MNIST'
elif dataSetNum == 2:
    pathToData = p0 + 'emnist/'; imgType = 'EMNIST'
else: print('Плохой номер набора данных'); sys.exit()
#
X_test, y_test_0, n_test = load_test(pathToData)
#
if dataSetNum == 1:
    num_classes = 10
else:
    num_classes = 26
y_pred = load_y_pred(fn1, num_classes)
print('Прогнозы из ' + fn1 + ':')
print(y_pred[0:3])
for m in range(1, nf):
    y_pred = make_y_pred(n_test, y_test_0, y_pred, lst_fn[m], num_classes)
print('Итоговые прогнозы:')
print(y_pred[0:3])
#
classes = []
for m in y_pred:
    classes.append(np.argmax(m))
nClassified = np.sum(classes == y_test_0)
nNotClassified = n_test - nClassified
acc = 100.0 * nClassified / n_test
print("Число ошибочно классифицированных образов: " + str(nNotClassified))
print("Точность прогнозирования: " + str(acc) + '%')
if showErrPics:
    if imgType == 'MNIST':
        X_test = X_test.reshape(n_test, 28, 28, 1)
    elif imgType == 'EMNIST':
        X_test = X_test.reshape(n_test, 28, 28, 1).transpose(0,2,1,3)
        y_test_0 -= 1
    names = makeNames(imgType)
    n = 0
    for i in range(n_test):
        s_true = names[y_test_0[i]]
        s_pred = names[classes[i]]
        if s_true != s_pred:
            n += 1
            if (n > nNotClassified): break
            str_i = str(i);
            print(str(n) + '. i = ' + str_i + '. На самом деле: ' + s_true + '. Прогноз: ' + s_pred)
            if n < 28:
                plt.subplot(3, 9, n)
                plt.imshow(X_test[i].reshape(28, 28), cmap = plt.get_cmap('gray'))
                plt.title(s_true + '/' + s_pred)
                plt.axis('off')
    plt.subplots_adjust(hspace = 0.5)
    plt.show()

Списки эффективных функций потерь

Списки эффективных функций потерь по критерию val_acc на наборах данных MNIST, EMNIST и CIFAR-10 построены по историям обучения нейронных сетей и приведены в табл. 21.

Таблица 21. Списки эффективных функций потерь по критерию val_acc на наборах данных MNIST, EMNIST и CIFAR-10

Приведенные в табл. 21 данные позволяют заключить следующее:

1. Нельзя переносить опыт обучения одной НС на другую, то есть нельзя утверждать, что функции потерь, эффективные для одной нейронной сети, будут эффективны для другой. Например, на MNIST для НС c1 эффективны следующие функции потерь: 'msle', 'mk', 'pss', 'bce', 'sh', а для НС c4 – только функция потерь 'ck'. Хотя бывают и совпадения. Например, на EMNIST НС 2c27 и c28 лучшим образом обучаются с функцией потерь 'mse'.
2. Разные функции потерь появляются в списках эффективных ФП с разной частотой.
3. При выборе функции потерь можно опираться на частотные диаграммы эффективности ФП, проверяя прежде ФП, наиболее часто появляющиеся в списках эффективных ФП. (Построенные по табл. 21 диаграммы частоты появления функций потерь в списках эффективных ФП показаны на рис. 25.)
4. При отсутствии частотных диаграмм эффективности ФП, например при работе с новым набором данных, поиск эффективных ФП следует вести, выполняя полный перебор доступных ФП.

Рис. 25. Частотные диаграммы эффективности функций потерь по критерию val_acc на наборах данных MNIST, EMNIST и CIFAR-10

Построение диаграмм обеспечивает следующий код.

import numpy as np
import matplotlib.pyplot as plt
dataSetNum = 3
if dataSetNum == 1:
    ttl = 'MNIST'
    lst = [['msle', 'mk', 'pss', 'bce', 'sh'], ['ck'],
         ['h', 'bce', 'lc', 'msle', 'mse'],
         ['kld', 'cce', 'ck'], ['pss', 'msle', 'cp'], ['cp'], ['bce'],
         ['mse', 'kld', 'pss'], ['kld', 'mae'], ['cce', 'scce', 'cp'],
         ['ck', 'msle', 'cp', 'bce', 'kld', 'mse'], ['mape', 'sh', 'h'],
         ['cce', 'ck', 'kld', 'cp', 'pss', 'h', 'scce', 'msle'],
         ['cce', 'mse'], ['cp', 'kld', 'ck', 'msle', 'sh', 'bce', 'cce'],
         ['cp', 'pss'], ['kld', 'scce'], ['scce'],
         ['msle', 'scce', 'kld', 'mk', 'cp', 'cce'], ['msle', 'pss', 'sh'],
         ['mape']]
elif dataSetNum == 2:
    ttl = 'EMNIST'
    lst = [['lc', 'msle', 'ck'], ['bce'], ['mse'], ['mse', 'msle'],
         ['mse', 'msle', 'lc'], ['sh', 'cp', 'msle'], ['ch'], ['msle'],
         ['mse'], ['msle', 'mse', 'lc', 'scce'], ['sh', 'cce', 'msle'],
         ['lc', 'sh'], ['msle', 'sh'], ['mse', 'lc'],
         ['cp', 'lc', 'scce', 'mse', 'kld', 'mk'], ['mse', 'ck', 'msle'],
         ['lc', 'msle'], ['sh', 'mse'], ['sh', 'lc'],
         ['cp', 'msle', 'lc', 'pss'], ['msle', 'mse', 'pss', 'mk', 'cp'],
         ['msle', 'ck'], ['mk', 'msle', 'sh'], ['lc'],
         ['mse', 'scce', 'msle'], ['lc'], ['mse'], ['mse'], ['lc'],
         ['lc', 'pss', 'msle'], ['msle', 'h', 'scce', 'mae'],
         ['msle', 'cp', 'mse', 'bce', 'lc', 'h', 'ch'], ['scce']]
else:
    ttl = 'CIFAR10'
    lst = [['cce', 'scce', 'msle'], ['bce', 'msle'], ['scce'],
         ['msle', 'bce', 'ck'], ['ck', 'mk'], ['cp', 'bce'],
         ['cce'], ['cp', 'mk'], ['cp'], ['bce', 'pss', 'cp'],
         ['cce', 'pss', 'kld', 'bce', 'ck'], ['scce', 'kld'],
         ['scce', 'kld', 'pss', 'mk'], ['bce', 'ch'], ['pss', 'bce']]
accF, accV = [], []
for e in lst:
    for ls in e:
        if ls in accF:
            ind = accF.index(ls)
            accV[ind] += 1
        else:
            accF.append(ls)
            accV.append(1)
n = len(accF)
lst = []
for k in range(n):
    lst.append([accF[k], accV[k]])
lst.sort(key = lambda r:(r[1]))
accF, accV = [], []
for k in range(n):
    fun = lst[k][0]
    v = lst[k][1]
    accV.append(v)
    accF.append(fun)
ind = np.arange(n)
width = 0.15 # Ширина столбца диаграммы
plt.figure(figsize = (6, 3.9))
if dataSetNum == 2: plt.ylim(0, 18)
plt.bar(ind, accV, width)
plt.xlabel('Функция потерь')
plt.ylabel('Частота')
plt.title(ttl)
plt.xticks(ind, accF)
plt.show()

Заключение

На языке Python с использование библиотеки Keras разработаны программные средства, обеспечивающие создание моделей НС по их строковому описанию, обучение и тестирование обученных моделей. Разработанные программы применены для обучения описанных в табл. 4 моделей НС.
Результаты (истории) обучения сохранены в текстовые файлы, содержащие для каждой эпохи обучения точность классификации и потери на обучающих и проверочных данных.
Разработаны программы анализа историй обучения, позволяющие выделять лучшие решения и эффективные функции потерь по критериям обучения corr_img, val_acc и acc, а также находить в каждом решении наибольшее число эпох между двумя последовательными обновлениями максимума критерия обучения и разницу между двумя последними обновлениями максимума критерия обучения.
Предусмотрены средства для графического отображения результатов обучения и их анализа.
Результаты обучения и разработанные программы приведены в приложениях. Результаты анализа историй обучения – в разд. Оценка результатов обучения, Погрешность оценки результатов обучения и Обработка историй обучения.
Созданы программы, находящие пересечение списков неверно классифицированных изображений разными моделями НС и отображающие эти пересечения в виде рисунков. Аналогичный результат можно получить, объединяя прогнозы разных моделей НС.
Обработка историй обучения позволила, в частности, выделить для каждой НС эффективные функции потерь. Нередко для НС эффективными являются несколько функций потерь. При этом в общем случае нельзя переносить опыт обучения одной НС на другую: поиск функций потерь, эффективных для проектируемой НС, выполняется в результате перебора всех доступных функций потерь.
В случае MNIST и EMNIST загрузка наборов данных выполняется из бинарных файлов. Путь к этим файлам содержит костанта pathToData.
В случае CIFAR-10 в папке, имя которой хранит константа pathToData, следует разместить папку cifar-10-batches-py с данными CIFAR-10.
Можно скачать все истории обучения. Для их обработки используются программа, приведенная в прил. 5.
Разработанные средства могут быть использованы для классификации и обработки результатов классификации изображений разных видов, в частности, MNIST, EMNIST CIFAR-10.

Источники

1. The MNIST database of handwritten digits. [Электронный ресурс] URL: http://yann.lecun.com/exdb/mnist/ (дата обращения: 01.01.2019).
2. The EMNIST dataset. [Электронный ресурс] URL: https://www.nist.gov/itl/iad/image-group/emnist-dataset (дата обращения: 01.01.2019).
3. The CIFAR-10 dataset. [Электронный ресурс] URL: http://www.cs.toronto.edu/~kriz/cifar.html (дата обращения: 01.01.2019).
4. Функции потерь библиотеки Keras. [Электронный ресурс] URL: http://100byte.ru/python/loss/loss.html (дата обращения: 01.01.2019).
5. He K., Zhang X., Ren S., Sun J. Deep Residual Learning for Image Recognition. [Электронный ресурс] URL: https://arxiv.org/pdf/1512.03385.pdf (дата обращения: 01.01.2019).
6. Keras documentation. Merge Layers. [Электронный ресурс] URL: https://keras.io/layers/merge/ (дата обращения: 01.01.2019).
7. Classification datasets results. [Электронный ресурс] URL: http://rodrigob.github.io/are_we_there_yet/build/classification_datasets_results (дата обращения: 01.01.2019).
8. Liu Y., Li H., Wang X. Rethinking feature discrimination and polymerization for large-scale recognition. [Электронный ресурс] URL: https://arxiv.org/pdf/1710.00870.pdf (дата обращения: 01.01.2019).
9. Gregory Cohen, Saeed Afshar, Jonathan Tapson, and Andre van Schaik. EMNIST: an extension of MNIST to handwritten letters. [Электронный ресурс] URL: https://arxiv.org/pdf/1702.05373v1.pdf (дата обращения: 01.01.2019).
10. Keras documentation. How can I obtain reproducible results using Keras during development? [Электронный ресурс] URL: https://keras.io/getting-started/faq/#how-can-i-obtain-reproducible-results-using-keras-during-development (дата обращения: 01.01.2019).

Приложение 1. Результаты обучения нейронных сетей

Результаты обучения перечисленных в табл. 4 моделей НС, приведены в табл. П1.

Таблица П1. Результаты обучения моделей НС (решения выбираются по критерию val_acc)