diff --git a/report.md b/report.md deleted file mode 100644 index 766ca17..0000000 --- a/report.md +++ /dev/null @@ -1,746 +0,0 @@ -# Отчёт по лабораторной работе №2 - -**Сидора Д.А. Пивоваров Я.В. А-02-22** - ---- -## Задание 1 - -### 1) В среде Google Colab создали новый блокнот (notebook). Импортировали необходимые для работы библиотеки и модули. - -```python -# скачивание библиотеки -!wget -N http://uit.mpei.ru/git/main/is_dnn/raw/branch/main/labworks/LW2/lab02_lib.py - -# скачивание выборок -!wget -N http://uit.mpei.ru/git/main/is_dnn/raw/branch/main/labworks/LW2/data/letter_train.txt -!wget -N http://uit.mpei.ru/git/main/is_dnn/raw/branch/main/labworks/LW2/data/letter_test.txt - -# импорт модулей -import os -os.chdir('/content/drive/MyDrive/Colab Notebooks/lab2') - -import numpy as np -import lab02_lib as lib -``` - -### 2) Сгенерировали индивидуальный набор двумерных данных в пространстве признаков с координатами центра (5, 5). Вывели полученные данные на рисунок и в консоль. - -```python -#генерация датасета -data=lib.datagen(5,5,1000,2) - -#вывод данных и размерности -print('Исходные данные:') -print(data) -print('Размерность данных:') -print(data.shape) -``` -![Training set](1.png) -``` -Исходные данные: -[[4.92346186 5.06160261] - [4.86776523 4.87688396] - [5.04434246 4.99621627] - ... - [5.08559661 4.90905577] - [5.13652538 5.08244034] - [5.04940858 4.87050374]] -Размерность данных: -(1000, 2) -``` - -### 3) Создали и обучили автокодировщик AE1 простой архитектуры, выбрав небольшое количество эпох обучения. Зафиксировали в таблице табл.1 количество скрытых слоёв и нейронов в них - -```python -# обучение AE1 -patience= 300 -ae1_trained, IRE1, IREth1= lib.create_fit_save_ae(data,'out/AE1.h5','out/AE1_ire_th.txt', 1000, False, patience) -``` - -### 4) Зафиксировали ошибку MSE, на которой обучение завершилось. Построили график ошибки реконструкции обучающей выборки. Зафиксировали порог ошибки реконструкции – порог обнаружения аномалий. - -Ошибка MSE_AE1 = 7.0839 - -```python -# Построение графика ошибки реконструкции -lib.ire_plot('training', IRE1, IREth1, 'AE1') -``` -![IRE for training set. AE1](2.png) - -### 5) Создали и обучили второй автокодировщик AE2 с усложненной архитектурой, задав большее количество эпох обучения - -```python -# обучение AE2 -ae2_trained, IRE2, IREth2 = lib.create_fit_save_ae(data,'out/AE2.h5','out/AE2_ire_th.txt', -3000, True, patience) -``` - -### 6) Зафиксировали ошибку MSE, на которой обучение завершилось. Построили график ошибки реконструкции обучающей выборки. Зафиксировали второй порог ошибки реконструкции – порог обнаружения аномалий. - -Ошибка MSE_AE2 = 0.0114 - -```python -# Построение графика ошибки реконструкции -lib.ire_plot('training', IRE2, IREth2, 'AE2') -``` -![IRE for training set. AE2](3.png) - -### 7) Рассчитали характеристики качества обучения EDCA для AE1 и AE2. Визуализировали и сравнили области пространства признаков, распознаваемые автокодировщиками AE1 и AE2. Сделали вывод о пригодности AE1 и AE2 для качественного обнаружения аномалий. - -```python -# построение областей покрытия и границ классов -# расчет характеристик качества обучения -numb_square = 20 -xx, yy, Z1 = lib.square_calc(numb_square, data, ae1_trained, IREth1, '1', True) -``` -![Autoencoder AE1. Training set. Class boundary](4.png) -``` -amount: 19 -amount_ae: 295 -``` -![Площади множеств Xt и Xd AE1](5.png) -![EDCA AE1](6.png) - -``` -Оценка качества AE1 -IDEAL = 0. Excess: 14.526315789473685 -IDEAL = 0. Deficit: 0.0 -IDEAL = 1. Coating: 1.0 -summa: 1.0 -IDEAL = 1. Extrapolation precision (Approx): 0.06440677966101695 -``` - - -```python -# построение областей покрытия и границ классов -# расчет характеристик качества обучения -numb_square = 20 -xx, yy, Z2 = lib.square_calc(numb_square, data, ae2_trained, IREth2, '2', True) -``` -![Autoencoder AE2. Training set. Class boundary](7.png) -``` -amount: 19 -amount_ae: 41 -``` -![Площади множеств Xt и Xd AE1](8.png) -![EDCA AE1](9.png) - -``` -Оценка качества AE2 -IDEAL = 0. Excess: 1.1578947368421053 -IDEAL = 0. Deficit: 0.0 -IDEAL = 1. Coating: 1.0 -summa: 1.0 -IDEAL = 1. Extrapolation precision (Approx): 0.46341463414634143 -``` - -```python -# сравнение характеристик качества обучения и областей аппроксимации -lib.plot2in1(data, xx, yy, Z1, Z2) -``` -![Сравнение обучения AE1 и AE2](10.png) - -### 8) Если автокодировщик AE2 недостаточно точно аппроксимирует область обучающих данных, то подобрать подходящие параметры автокодировщика и повторить шаги (6) – (8). - -Полученные показатели EDCA для автокодировщика AE2 нас устраивают. - -### 9) Изучили сохраненный набор данных и пространство признаков. Создали тестовую выборку, состоящую, как минимум, из 4ёх элементов, не входящих в обучающую выборку. Элементы должны быть такими, чтобы AE1 распознавал их как норму, а AE2 детектировал как аномалии. - -```python -# загрузка тестового набора -data_test = np.loadtxt('data_test.txt', dtype=float) -print(data_test) -``` -``` -[[ 4.856234 5.123456] - [ 5.234567 4.876543] - [ 4.765432 5.345678] - [ 5.123456 4.987654] - [ 4.987654 5.234567] - [ 5.345678 4.765432] - [ 4.876543 5.432109] - [ 5.432109 4.654321] - [ 4.654321 5.56789 ] - [ 5.56789 4.54321 ] - [ 6.856234 6.123456] - [ 7.234567 6.876543] - [ 6.765432 7.345678] - [ 7.123456 6.987654] - [ 6.987654 7.234567] - [ 7.345678 6.765432] - [ 6.876543 7.432109] - [ 7.432109 6.654321] - [ 6.654321 7.56789 ] - [ 7.56789 6.54321 ] - [ 3.156234 3.123456] - [ 2.734567 3.876543] - [ 3.265432 2.654321] - [ 2.876543 3.234567] - [ 3.423456 2.987654] - [ 2.987654 3.345678] - [ 3.576543 2.765432] - [ 2.654321 3.432109] - [ 3.687654 2.56789 ] - [ 2.54321 3.56789 ] - [ 5.123456 7.876543] - [ 4.876543 8.234567] - [ 5.234567 7.654321] - [ 4.765432 8.123456] - [ 5.345678 7.432109] - [ 4.654321 8.345678] - [ 5.432109 7.234567] - [ 4.54321 8.456789] - [ 5.56789 7.123456] - [ 4.432109 8.56789 ] - [ 7.856234 5.123456] - [ 8.234567 4.876543] - [ 7.765432 5.345678] - [ 8.123456 4.987654] - [ 7.987654 5.234567] - [ 8.345678 4.765432] - [ 7.876543 5.432109] - [ 8.432109 4.654321] - [ 7.654321 5.56789 ] - [ 8.56789 4.54321 ] - [14.856234 14.123456] - [15.234567 14.876543] - [14.765432 15.345678] - [15.123456 14.987654] - [14.987654 15.234567] - [15.345678 14.765432] - [14.876543 15.432109] - [15.432109 14.654321] - [14.654321 15.56789 ] - [15.56789 14.54321 ] - [-0.856234 -0.123456] - [ 0.234567 -0.876543] - [-0.765432 0.345678] - [ 0.123456 -0.987654] - [-0.987654 0.234567] - [ 0.345678 -0.765432] - [-0.876543 0.432109] - [ 0.432109 -0.654321] - [-0.654321 0.56789 ] - [ 0.56789 -0.54321 ] - [17.856234 4.123456] - [18.234567 4.876543] - [17.765432 5.345678] - [18.123456 4.987654] - [17.987654 5.234567] - [18.345678 4.765432] - [17.876543 5.432109] - [18.432109 4.654321] - [17.654321 5.56789 ] - [18.56789 4.54321 ] - [-3.123456 22.876543] - [ 2.345678 18.654321] - [ 8.765432 -1.234567] - [12.345678 23.456789] - [-4.123456 7.876543] - [19.234567 19.876543] - [-2.876543 -2.123456] - [22.345678 3.654321] - [15.432109 -3.234567] - [-1.54321 25.56789 ] - [ 0. 15. ] - [ 2.5 16.25 ] - [ 5. 17.5 ] - [ 7.5 18.75 ] - [10. 20. ] - [12.5 21.25 ] - [15. 22.5 ] - [17.5 23.75 ] - [20. 25. ] - [22.5 26.25 ]] -Размерность data_test: (100, 2) -``` -В данной тестовой выборке среди 100 примеров: 10 нормальные данные(строки 1-10), 40 пограничные случаи (строки 11-50), 50 аномалий, из которых 15 являются сложными для обнаружения(точки рядом с границей) и 35 являются легко обнаружимыми (находятся по углам двумерного набора данных) - - -### 10) Применили обученные автокодировщики AE1 и AE2 к тестовым данным и вывели значения ошибки реконструкции для каждого элемента тестовой выборки относительно порога на график и в консоль. - -```python -# тестирование АE1 -predicted_labels1, ire1 = lib.predict_ae(ae1_trained, data_test, IREth1) -``` - -```python -# тестирование АE1 -lib.anomaly_detection_ae(predicted_labels1, ire1, IREth1) -lib.ire_plot('test', ire1, IREth1, 'AE1') -``` -``` -i Labels IRE IREth -0 [0.] [3.73] 4.11 -1 [0.] [3.88] 4.11 -2 [0.] [3.81] 4.11 -3 [0.] [3.85] 4.11 -4 [0.] [3.9] 4.11 -5 [0.] [3.92] 4.11 -6 [0.] [3.95] 4.11 -7 [0.] [3.93] 4.11 -8 [0.] [3.89] 4.11 -9 [0.] [4.] 4.11 -10 [1.] [5.92] 4.11 -11 [1.] [6.67] 4.11 -12 [1.] [6.63] 4.11 -13 [1.] [6.66] 4.11 -14 [1.] [6.72] 4.11 -15 [1.] [6.69] 4.11 -16 [1.] [6.77] 4.11 -17 [1.] [6.7] 4.11 -18 [1.] [6.71] 4.11 -19 [1.] [6.75] 4.11 -20 [0.] [1.23] 4.11 -21 [0.] [1.41] 4.11 -22 [0.] [1.28] 4.11 -23 [0.] [1.03] 4.11 -24 [0.] [1.46] 4.11 -25 [0.] [1.18] 4.11 -26 [0.] [1.59] 4.11 -27 [0.] [1.] 4.11 -28 [0.] [1.7] 4.11 -29 [0.] [1.05] 4.11 -30 [1.] [6.04] 4.11 -31 [1.] [6.26] 4.11 -32 [1.] [5.91] 4.11 -33 [1.] [6.12] 4.11 -34 [1.] [5.78] 4.11 -35 [1.] [6.3] 4.11 -36 [1.] [5.67] 4.11 -37 [1.] [6.38] 4.11 -38 [1.] [5.66] 4.11 -39 [1.] [6.48] 4.11 -40 [1.] [6.33] 4.11 -41 [1.] [6.59] 4.11 -42 [1.] [6.33] 4.11 -43 [1.] [6.53] 4.11 -44 [1.] [6.49] 4.11 -45 [1.] [6.66] 4.11 -46 [1.] [6.47] 4.11 -47 [1.] [6.71] 4.11 -48 [1.] [6.33] 4.11 -49 [1.] [6.81] 4.11 -50 [1.] [17.17] 4.11 -51 [1.] [17.96] 4.11 -52 [1.] [17.94] 4.11 -53 [1.] [17.95] 4.11 -54 [1.] [18.02] 4.11 -55 [1.] [17.97] 4.11 -56 [1.] [18.08] 4.11 -57 [1.] [17.96] 4.11 -58 [1.] [18.02] 4.11 -59 [1.] [17.99] 4.11 -60 [0.] [2.12] 4.11 -61 [0.] [3.66] 4.11 -62 [0.] [1.86] 4.11 -63 [0.] [3.73] 4.11 -64 [0.] [1.79] 4.11 -65 [0.] [3.58] 4.11 -66 [0.] [1.76] 4.11 -67 [0.] [3.5] 4.11 -68 [0.] [1.84] 4.11 -69 [0.] [3.4] 4.11 -70 [1.] [15.92] 4.11 -71 [1.] [16.38] 4.11 -72 [1.] [15.98] 4.11 -73 [1.] [16.28] 4.11 -74 [1.] [16.19] 4.11 -75 [1.] [16.48] 4.11 -76 [1.] [16.11] 4.11 -77 [1.] [16.55] 4.11 -78 [1.] [15.91] 4.11 -79 [1.] [16.67] 4.11 -80 [1.] [22.45] 4.11 -81 [1.] [17.93] 4.11 -82 [1.] [7.85] 4.11 -83 [1.] [23.23] 4.11 -84 [1.] [8.76] 4.11 -85 [1.] [24.31] 4.11 -86 [0.] [3.67] 4.11 -87 [1.] [20.37] 4.11 -88 [1.] [14.71] 4.11 -89 [1.] [24.9] 4.11 -90 [1.] [14.24] 4.11 -91 [1.] [15.55] 4.11 -92 [1.] [17.18] 4.11 -93 [1.] [18.58] 4.11 -94 [1.] [19.23] 4.11 -95 [1.] [21.29] 4.11 -96 [1.] [23.65] 4.11 -97 [1.] [26.11] 4.11 -98 [1.] [28.63] 4.11 -99 [1.] [31.19] 4.11 -Обнаружено 69.0 аномалий -``` -![IRE fir test set. AE1](11.png) - -```python -# тестирование АE2 -predicted_labels2, ire2 = lib.predict_ae(ae2_trained, data_test, IREth2) -``` - -```python -# тестирование АE2 -lib.anomaly_detection_ae(predicted_labels2, ire2, IREth2) -lib.ire_plot('test', ire2, IREth2, 'AE2') -``` -``` - -i Labels IRE IREth -0 [0.] [0.14] 0.48 -1 [0.] [0.35] 0.48 -2 [0.] [0.38] 0.48 -3 [0.] [0.21] 0.48 -4 [0.] [0.26] 0.48 -5 [1.] [0.49] 0.48 -6 [0.] [0.44] 0.48 -7 [1.] [0.62] 0.48 -8 [1.] [0.63] 0.48 -9 [1.] [0.8] 0.48 -10 [1.] [2.25] 0.48 -11 [1.] [3.] 0.48 -12 [1.] [3.] 0.48 -13 [1.] [2.98] 0.48 -14 [1.] [3.06] 0.48 -15 [1.] [3.02] 0.48 -16 [1.] [3.14] 0.48 -17 [1.] [3.02] 0.48 -18 [1.] [3.11] 0.48 -19 [1.] [3.08] 0.48 -20 [1.] [2.56] 0.48 -21 [1.] [2.44] 0.48 -22 [1.] [2.86] 0.48 -23 [1.] [2.68] 0.48 -24 [1.] [2.49] 0.48 -25 [1.] [2.53] 0.48 -26 [1.] [2.59] 0.48 -27 [1.] [2.74] 0.48 -28 [1.] [2.71] 0.48 -29 [1.] [2.76] 0.48 -30 [1.] [2.89] 0.48 -31 [1.] [3.25] 0.48 -32 [1.] [2.68] 0.48 -33 [1.] [3.14] 0.48 -34 [1.] [2.48] 0.48 -35 [1.] [3.37] 0.48 -36 [1.] [2.31] 0.48 -37 [1.] [3.49] 0.48 -38 [1.] [2.23] 0.48 -39 [1.] [3.61] 0.48 -40 [1.] [2.95] 0.48 -41 [1.] [3.33] 0.48 -42 [1.] [2.88] 0.48 -43 [1.] [3.21] 0.48 -44 [1.] [3.09] 0.48 -45 [1.] [3.44] 0.48 -46 [1.] [3.] 0.48 -47 [1.] [3.54] 0.48 -48 [1.] [2.81] 0.48 -49 [1.] [3.69] 0.48 -50 [1.] [13.5] 0.48 -51 [1.] [14.3] 0.48 -52 [1.] [14.3] 0.48 -53 [1.] [14.29] 0.48 -54 [1.] [14.37] 0.48 -55 [1.] [14.3] 0.48 -56 [1.] [14.44] 0.48 -57 [1.] [14.29] 0.48 -58 [1.] [14.38] 0.48 -59 [1.] [14.31] 0.48 -60 [1.] [6.74] 0.48 -61 [1.] [7.48] 0.48 -62 [1.] [6.97] 0.48 -63 [1.] [7.63] 0.48 -64 [1.] [6.8] 0.48 -65 [1.] [7.33] 0.48 -66 [1.] [6.95] 0.48 -67 [1.] [7.19] 0.48 -68 [1.] [6.9] 0.48 -69 [1.] [7.03] 0.48 -70 [1.] [12.98] 0.48 -71 [1.] [13.33] 0.48 -72 [1.] [12.86] 0.48 -73 [1.] [13.21] 0.48 -74 [1.] [13.08] 0.48 -75 [1.] [13.44] 0.48 -76 [1.] [12.98] 0.48 -77 [1.] [13.53] 0.48 -78 [1.] [12.76] 0.48 -79 [1.] [13.67] 0.48 -80 [1.] [19.63] 0.48 -81 [1.] [13.96] 0.48 -82 [1.] [7.32] 0.48 -83 [1.] [19.91] 0.48 -84 [1.] [9.39] 0.48 -85 [1.] [20.66] 0.48 -86 [1.] [7.18] 0.48 -87 [1.] [17.49] 0.48 -88 [1.] [13.36] 0.48 -89 [1.] [21.6] 0.48 -90 [1.] [11.17] 0.48 -91 [1.] [11.57] 0.48 -92 [1.] [12.57] 0.48 -93 [1.] [14.] 0.48 -94 [1.] [15.85] 0.48 -95 [1.] [17.95] 0.48 -96 [1.] [20.21] 0.48 -97 [1.] [22.59] 0.48 -98 [1.] [25.06] 0.48 -99 [1.] [27.59] 0.48 -Обнаружено 94.0 аномалий - -``` -| Параметр | AE1 | AE2 | -|----------|-----|-----| -| **True Positive (TP)** | 29 | 50 | -| **True Negative (TN)** | 10 | 4 | -| **False Positive (FP)** | 29 | 46 | -| **False Negative (FN)** | 21 | 0 | - -![IRE fir test set. AE2](12.png) - -### 11) Визуализировали элементы обучающей и тестовой выборки в областях пространства признаков, распознаваемых автокодировщиками AE1 и AE2. - -```python -# построение областей аппроксимации и точек тестового набора -lib.plot2in1_anomaly(data, xx, yy, Z1, Z2, data_test) -``` -![Сравнение теста AE1 и AE2](13.png) - -### 12) Результаты исследования занесли в таблицу: -Табл. 1 Результаты задания №1 - -| | Количество скрытых слоев | Количество нейронов в скрытых слоях | Количество эпох обучения | Ошибка MSE_stop | Порог ошибки реконструкции | Значение показателя Excess | Значение показателя Approx | Количество обнаруженных аномалий | -|-----:|------------------------------|----------------------------------------|-----------------------------|--------------------|-------------------------------|-------------------------------|--------------------------------|-------------------------------------| -| AE1 | 1 | 1 | 1000 | 7.0839 | 4.16 | 14.526 | 0.064 | 69 | -| AE2 | 5 | 3,2,1,2,3 | 3000 | 0.0114 | 0.48 | 1.158 | 0.463 | 94 | - -### 13) Сделали выводы о требованиях к: -- данным для обучения, -- архитектуре автокодировщика, -- количеству эпох обучения, -- ошибке MSE_stop, приемлемой для останова обучения, -- ошибке реконструкции обучающей выборки (порогу обнаружения -аномалий), -- характеристикам качества обучения EDCA одноклассового -классификатора - -для качественного обнаружения аномалий в данных. - -1) Данные для обучения должны быть без аномалий, чтобы автокодировщик смог рассчитать верное пороговое значение -2) Слишком простая архитектура, как у AE1, приводит к неполному выявлению аномалий. Напротив, архитектура, как у AE2, приводит к переобучению -3) 1000 эпох - недостаточно, 3000 - избыточно -4) Оптимальная ошибка MSE-stop в диапазоне 0.1- 0.01, желательно не меньше для предотвращения переобучения -5) 4.16 адекватный, но завышен из-за выбросов. 0.48 слишком низкий, чрезмерная чувствительность. -6) Значение Excess не больше 0.5, значение Deficit равное 0, значение Coating равное 1, значение Approx не меньше 0.7 - -## Задание 2 - -### 1) Изучить описание своего набора реальных данных, что он из себя представляет - -Бригада 4 => набор данных Letter. Он представляет собой набор данных для многоклассовой классификации. Набор предназначен для распознавания черно-белых пиксельных прямоугольниковкак одну из 26 заглавных букв английского алфавита, где буквы алфавита представлены в 16 измерениях. Чтобы получить данные, подходящие для обнаружения аномалий, была произведена подвыборка данных из 3 букв, чтобы сформировать нормальный класс, и случайным образом их пары были объединены так, чтобы их размерность удваивалась. Чтобы сформировать класс аномалий, случайным образом были выбраны несколько экземпляров букв, которые не входят нормальный класс, и они были объединены с экземплярами из нормального класса. Процесс объединения выполняется для того, чтобы сделать обнаружение более сложным, поскольку каждый аномальный пример также будет иметь некоторые нормальные значения признаков - -| Количество признаков | Количество примеров | Количество нормальных примеров | Количество аномальных примеров | -|-------------------------:|-----------------------:|----------------------------------:|-----------------------------------:| -| 32 | 1600 | 1500 | 100 | - -### 2) Загрузить многомерную обучающую выборку реальных данных Letter.txt. - -```python -# загрузка обчуающей выборки -train= np.loadtxt('letter_train.txt', dtype=float) -``` - -### 3) Вывести полученные данные и их размерность в консоли. - -```python -print('train:\n', train) -print('train.shape:', np.shape(train)) -``` -``` -train: - [[ 6. 10. 5. ... 10. 2. 7.] - [ 0. 6. 0. ... 8. 1. 7.] - [ 4. 7. 5. ... 8. 2. 8.] - ... - [ 7. 10. 10. ... 8. 5. 6.] - [ 7. 7. 10. ... 6. 0. 8.] - [ 3. 4. 5. ... 9. 5. 5.]] -train.shape: (1500, 32) -``` -### 4) Создать и обучить автокодировщик с подходящей для данных архитектурой. Выбрать необходимое количество эпох обучения. - -```python - -patience = 5000 -ae3_trained, IRE3, IREth3= lib.create_fit_save_ae(train,'out/AE3.h5','out/AE3_ire_th.txt', 100000, False, patience) - -``` - -### 5) Зафиксировать ошибку MSE, на которой обучение завершилось. Построить график ошибки реконструкции обучающей выборки. Зафиксировать порог ошибки реконструкции – порог обнаружения аномалий. - -Скрытых слоев 7, нейроны: 14 12 9 7 9 12 14 - -Ошибка MSE_AE3 = 0.9383 - -```python -# Построение графика ошибки реконструкции -lib.ire_plot('training', IRE3, IREth3, 'AE3') -``` -![IRE for training set. AE3](14.png) - -### 6) Сделать вывод о пригодности обученного автокодировщика для качественного обнаружения аномалий. Если порог ошибки реконструкции слишком велик, то подобрать подходящие параметры автокодировщика и повторить шаги (4) – (6). - -```python -# обучение AE3.2 -patience=5000 -ae32_trained, IRE32, IREth32= lib.create_fit_save_ae(train,'out/AE32.h5','out/AE32_ire_th.txt', 100000, False, patience) -``` - -Скрытых слоев 7, нейроны: 12 10 8 7 8 10 12 - -Ошибка MSE_AE32 = 0.9393 - -```python -# Построение графика ошибки реконструкции -lib.ire_plot('training', IRE32, IREth32, 'AE32') -``` -![IRE for training set. AE32](16.png) - -```python -# обучение AE3.3 -patience=5000 -ae33_trained, IRE33, IREth33= lib.create_fit_save_ae(train,'out/AE33.h5','out/AE33_ire_th.txt', 100000, False, patience) -``` - -Скрытых слоев 7, нейроны: 10 9 8 7 8 9 10 - -Ошибка MSE_AE33 = 1.0524 - -```python -# Построение графика ошибки реконструкции -lib.ire_plot('training', IRE33, IREth33, 'AE33') -``` -![IRE for training set. AE33](18.png) - -```python -# обучение AE3.4 -patience=5000 -ae34_trained, IRE34, IREth34=lib.create_fit_save_ae(train,'out/AE34.h5','out/AE34_ire_th.txt', 100000, False, patience) - -``` - -Скрытых слоев 11, нейроны: 48 36 28 22 16 10 16 22 28 36 48 - -Ошибка MSE_AE34 = 0.3074 - -```python -# Построение графика ошибки реконструкции -lib.ire_plot('training', IRE34, IREth34, 'AE34') -``` -![IRE for training set. AE34](20.png) - -### 7) Изучить и загрузить тестовую выборку Letter.txt. - -```python -#загрузка тестовой выборки -test = np.loadtxt('letter_test.txt', dtype=float) -print('\n test:\n', test) -print('test.shape:', np.shape(test)) -``` -``` - test: - [[ 8. 11. 8. ... 7. 4. 9.] - [ 4. 5. 4. ... 13. 8. 8.] - [ 3. 3. 5. ... 8. 3. 8.] - ... - [ 4. 9. 4. ... 8. 3. 8.] - [ 6. 10. 6. ... 9. 8. 8.] - [ 3. 1. 3. ... 9. 1. 7.]] -test.shape: (100, 32) -``` -### 8) Подать тестовую выборку на вход обученного автокодировщика для обнаружения аномалий. Вывести график ошибки реконструкции элементов тестовой выборки относительно порога. - -```python -#тестирование АE3 -predicted_labels3, ire3 = lib.predict_ae(ae3_trained, test, IREth3) -#тестированиеАE3 -lib.anomaly_detection_ae(predicted_labels3, ire3, IREth3) - -``` - -```python -# Построение графика ошибки реконструкции -lib.ire_plot('test', ire3, IREth3, 'AE3') -``` -![IRE for test set. AE3](15.png) - -```python -#тестирование АE32 -predicted_labels32, ire32 = lib.predict_ae(ae32_trained, test, IREth32) -#тестированиеАE32 -lib.anomaly_detection_ae(predicted_labels32, ire32, IREth32) - -``` - -```python -# Построение графика ошибки реконструкции -lib.ire_plot('test', ire32, IREth32, 'AE32') -``` -![IRE for test set. AE32](17.png) - -```python -#тестирование АE33 -predicted_labels33, ire33 = lib.predict_ae(ae33_trained, test, IREth33) -#тестированиеАE33 -lib.anomaly_detection_ae(predicted_labels33, ire33, IREth33) - -``` - -```python -# Построение графика ошибки реконструкции -lib.ire_plot('test', ire33, IREth33, 'AE33') -``` -![IRE for test set. AE33](19.png) - -```python -#тестирование АE34 -predicted_labels34, ire34 = lib.predict_ae(ae34_trained, test, IREth34) -#тестированиеАE34 -lib.anomaly_detection_ae(predicted_labels34, ire34, IREth34) -``` - -```python -# Построение графика ошибки реконструкции -lib.ire_plot('test', ire34, IREth34, 'AE34') -``` -![IRE for test set. AE34](21.png) - -### 9) Если результаты обнаружения аномалий не удовлетворительные (обнаружено менее 70% аномалий), то подобрать подходящие параметры автокодировщика и повторить шаги (4) – (9). - -Результаты обнаружения аномалий удовлетворены. - -### 10) Параметры наилучшего автокодировщика и результаты обнаружения аномалий занести в таблицу: -Табл. 2 Результаты задания №2 - -| Dataset name | Количество скрытых слоев | Количество нейронов в скрытых слоях | Количество эпох обучения | Ошибка MSE_stop | Порог ошибки реконструкции | % обнаруженных аномалий | -|:-------------|:-----------------------------|:----------------------------------------|:-----------------------------|:-------------------|:-------------------------------|:---------------------------| -| Cardio | 11 | 48 36 28 22 16 10 16 22 28 36 48 | 100000 | 0.3074 | 7.3 | 85% | - -### 11) Сделать выводы о требованиях к: -- данным для обучения, -- архитектуре автокодировщика, -- количеству эпох обучения, -- ошибке MSE_stop, приемлемой для останова обучения, -- ошибке реконструкции обучающей выборки (порогу обнаружения -аномалий) - -для качественного обнаружения аномалий в случае, когда размерность -пространства признаков высока. - -1) Данные для обучения должны быть без аномалий, чтобы автокодировщик смог рассчитать верное пороговое значение -2) Архитектура автокодировщика должна постепенно сужатся к бутылочному горлышку,а затем постепенно возвращатся к исходным выходным размерам, кол-во скрытых слоев 7-11. -3) В рамках данного набора данных оптимальное кол-во эпох 100000 с patience 5000 эпох -4) Оптимальная ошибка MSE-stop в районе 0.1, желательно не меньше для предотвращения переобучения -5) Значение порога не больше 1.6