Delete Logging_Error_Анализ_Данных_Синтетич.py

Logging_Error_Анализ_Данных_Синтетич.py

@@ -1,1109 +0,0 @@
-# Модель связывает организацию кода в части использования разных программных модулей для разных архитектурных элементов (маркированных классов)
-# с количеством фиксируемых ошибок в работе кода.
-# Анализ данных, синтез данных.
-
-# Метолика использования.
-# Удаление строк из data не удовлетворяющих условиям: < data_Max и >= data_Min
-# Удаление дублирующихся строк, оставлены первые вхождения
-# Заполнение пустых ячеек нулевыми значениями, если нужно
-# 0. Увеличение количества СТОЛБЦОВ датасета, если нужно ???
-# 1. Генерация нулевых значений данных (из одной строки с нулями - файл Logging_Error_Исходн_0.xlsx).
-# 1.1. Сгенерировать нулевые значения входных параметров.
-# 1.2. Сгенерировать нулевые значения выходов - target.
-# 1.3. Зашумить данные нормальным шумом с K_SKO = 0.0001 - выходной файл Logging_Error_0.xlsx. 
-# 2. Генерация значений входных параметров с заданным шагом.
-# 2.1. Сгенерировать значения входных параметров с заданным шагом - входной файл из одной строки с нулями Logging_Error_Исходн_0.xlsx.
-# 2.2. Вычислить значения выходов - target - выходной файл Logging_Error_перебор_значений_0.xlsx.
-# 2.3. Зашумить данные нормальным шумом с K_SKO = 0.0001 - выходной файл Logging_Error_перебор_значений_шум.xlsx.
-# 3. Генерация значений входных параметров на основе реальных данных.
-# 3.1. Увеличение количества строк в датасете на основе случайного изменения исходного датасета - входной файл Logging_Error_Исходн_Синт.xlsx.
-# 3.2. Вычислить значения выходов - target - входной файл Logging_Error_увел_исходн.xlsx, выходной - Logging_Error_увел_исходн_target.xlsx.
-# 3.3. Зашумить данные нормальным шумом с K_SKO = 0.0001 - выходной файл Modules_Error_шум_исходн_target.xlsx.
-# 4. Объединить все сгенерированные данные в один файл - итоговый файл Logging_Error_Синтетические.xlsx.
-
-# 5. Генерация данных на основе полного перебора значений с заданным шагом
-# 5.1. Генерация данных входных параметров на основе полного перебора значений с заданным шагом - входной файл из одной строки с нулями Logging_Error_Исходн_0.xlsx.
-# 5.2. 3.2. Вычисление количества ошибок (target) на основе количества и соотношения LOG, lack - входной файл Logging_Error_полн_перебор.xlsx, выходной - Logging_Error_полн_перебор_target.xlsx.
-# 5.3. 3.3. Зашумить данные нормальным шумом с K_SKO = 0.0001 - выходной файл Logging_Error_Синтетические.xlsx.
-
-
-
-
-
-# импорт библиотек
-import os
-import warnings
-warnings.filterwarnings(action='ignore')
-from tensorflow import keras
-import pickle
-import pandas as pd
-import numpy as np
-import copy
-from sklearn.model_selection import cross_validate
-from sklearn.base import BaseEstimator, TransformerMixin
-from sklearn.utils import check_array
-from sklearn.impute import SimpleImputer
-from sklearn.feature_selection import SelectFwe, f_regression, VarianceThreshold
-from sklearn.cluster import FeatureAgglomeration
-from sklearn.linear_model import LassoLarsCV, LassoCV
-from sklearn.decomposition import PCA
-from sklearn.ensemble import ExtraTreesRegressor
-from sklearn.pipeline import Pipeline
-from sklearn.metrics import r2_score, mean_absolute_error, mean_squared_error
-import random
-from numba import njit
-from numba import types
-from numba.typed import Dict
-
-import matplotlib.pyplot as plt
-#import seaborn as sb
-
-# Монтаж Google Диска
-#from google.colab import drive
-#drive.mount('/content/drive')
-
-# Параметры модели ------------------------------------------------------------------------------
-data_path = 'C:\\Work\Python_Work1\\GIGA IDE\Logirovanie\\03 Анализ данных\\ИД Синтетическме 03_10000\\Logging_Error_00.xlsx' # Путь к исходным данным
-data_save_path = 'C:\\Work\Python_Work1\\GIGA IDE\Logirovanie\\03 Анализ данных\\ИД Синтетическме 03_10000\\Logging_Error_00_.xlsx' # Путь для сохранения данным
-model_name = 'Model_Logging_Error.keras' # Имя файла модели
-img_file = 'Structure_model.png' # Имя файла структуры модели
-inp_file = 'inp_monitoring-dataset.xlsx' # Имя файла с входными данными для прогноза
-num_increment_cycles = 20 #2000 #40 #36 # 80 Количество циклов увеличения строк данных
-#SKO_random_normal = 5 # СКО нормального распределения при расширении исходного датасета
-K_SKO = 0.0001 # 0.2 # Коэффициент для определения СКО
-SKO_random_normal = 0.2 # Коэффициент для определения СКО
-data_Min = 1
-data_Max = 10000 # 10000
-data_Max_2 = data_Max * 0.5
-target_min = 1
-#X_max = 100000
-#y_max = 100000
-# -----------------------------------------------------------------------------------------------
-
-# версии библиотек
-import sklearn
-import pandas
-import numpy
-import tensorflow
-
-print(f'{sklearn.__version__=}')
-print(f'{pandas.__version__=}')
-print(f'{numpy.__version__=}')
-print(f'{tensorflow.__version__=}')
-
-#from google.colab import files
-#uploaded = files.upload() # Загрузка файла с компьютера
-
-target = 'target'
-num_features = [
-    'markers.MON_CATCH_LOG',
-    'markers.MON_CATCH_LOG_LACK',
-    'markers.MON_TRY_LOG',
-    'markers.MON_TRY_LOG_LACK',
-    'markers.MON_COMPONENT_DEBUG',
-    'markers.MON_COMPONENT_LACK_DEBUG',
-    'markers.MON_COMPONENT_ERROR',
-    'markers.MON_COMPONENT_LACK_ERROR',
-    'markers.MON_COMPONENT_INFO',
-    'markers.MON_COMPONENT_LACK_INFO',
-    'markers.MON_COMPONENT_LOG',
-    'markers.MON_COMPONENT_LACK_LOG',
-    'markers.MON_COMPONENT_TRACE',
-    'markers.MON_COMPONENT_LACK_TRACE',
-    'markers.MON_COMPONENT_WARN',
-    'markers.MON_COMPONENT_LACK_WARN',
-    'markers.MON_CONTROLLER_DEBUG',
-    'markers.MON_CONTROLLER_LACK_DEBUG',
-    'markers.MON_CONTROLLER_ERROR',
-    'markers.MON_CONTROLLER_LACK_ERROR',
-    'markers.MON_CONTROLLER_INFO',
-    'markers.MON_CONTROLLER_LACK_INFO',
-    'markers.MON_CONTROLLER_LOG',
-    'markers.MON_CONTROLLER_LACK_LOG',
-    'markers.MON_CONTROLLER_TRACE',
-    'markers.MON_CONTROLLER_LACK_TRACE',
-    'markers.MON_CONTROLLER_WARN',
-    'markers.MON_CONTROLLER_LACK_WARN',
-    'markers.MON_REPOSITORY_DEBUG',
-    'markers.MON_REPOSITORY_LACK_DEBUG',
-    'markers.MON_REPOSITORY_ERROR',
-    'markers.MON_REPOSITORY_LACK_ERROR',
-    'markers.MON_REPOSITORY_INFO',
-    'markers.MON_REPOSITORY_LACK_INFO',
-    'markers.MON_REPOSITORY_LOG',
-    'markers.MON_REPOSITORY_LACK_LOG',
-    'markers.MON_REPOSITORY_TRACE',
-    'markers.MON_REPOSITORY_LACK_TRACE',
-    'markers.MON_REPOSITORY_WARN',
-    'markers.MON_REPOSITORY_LACK_WARN',
-    'markers.MON_RESTCONTROLLER_DEBUG',
-    'markers.MON_RESTCONTROLLER_LACK_DEBUG',
-    'markers.MON_RESTCONTROLLER_ERROR',
-    'markers.MON_RESTCONTROLLER_LACK_ERROR',
-    'markers.MON_RESTCONTROLLER_INFO',
-    'markers.MON_RESTCONTROLLER_LACK_INFO',
-    'markers.MON_RESTCONTROLLER_LOG',
-    'markers.MON_RESTCONTROLLER_LACK_LOG',
-    'markers.MON_RESTCONTROLLER_TRACE',
-    'markers.MON_RESTCONTROLLER_LACK_TRACE',
-    'markers.MON_RESTCONTROLLER_WARN',
-    'markers.MON_RESTCONTROLLER_LACK_WARN',
-    'markers.MON_SERVICE_DEBUG',
-    'markers.MON_SERVICE_LACK_DEBUG',
-    'markers.MON_SERVICE_ERROR',
-    'markers.MON_SERVICE_LACK_ERROR',
-    'markers.MON_SERVICE_INFO',
-    'markers.MON_SERVICE_LACK_INFO',
-    'markers.MON_SERVICE_LOG',
-    'markers.MON_SERVICE_LACK_LOG',
-    'markers.MON_SERVICE_TRACE',
-    'markers.MON_SERVICE_LACK_TRACE',
-    'markers.MON_SERVICE_WARN',
-    'markers.MON_SERVICE_LACK_WARN',
-    'markers.cyclomatic_complexity_LACK',	
-    'markers.lines_of_code_LACK',	
-    'markers.lambda_count_LACK',	
-    'markers.nesting_depth_LACK',	
-    'markers.try_catch_count_LACK'
-]                
-
-# Чтение данных
-#data = pd.read_excel('Logging_Error.xlsx')
-data = pd.read_excel(data_path)
-data = data.astype(float)
-data.shape
-print('data.shape = ', data.shape)
-
-# Удаление дублирующихся строк, оставлены первые вхождения
-data = data.drop_duplicates(subset=num_features)
-
-# Удаление строк с дубликатами в столбце 'target', оставлены первые вхождения
-# Округляем значение в столбце 'target' 
-# data['target'] = data['target'].round(3)
-# data = data.drop_duplicates(subset=['target'], keep='first')
-
-# Удаление индексов строк из датафрейма
-data = data.reset_index(drop=True)
-print('Удаление дублирующихся строк')
-print('data.shape = ', data.shape)
-
-
-
-
-'''
-# 1.1, 1.2, 1.3. Генерация нулевых значений данных ------------------------------------------------------------------------------------
-# Увеличение количества строк в датасете и зашумление на основе случайного изменения одной строки с нулями
-
-# Выделение столбцов с логированием (LOG) и без логирования (lack)
-lack_cols = [x for x in num_features if '_lack' in x]
-LOG_cols = [x for x in num_features if not '_lack' in x]
-
-data_ = copy.deepcopy(data)
-data__ = copy.deepcopy(data)
-
-data_shape_0 = data.shape[0]
-for j in range(num_increment_cycles):
-    print('j = ', j)
-
-    # Случайное изменение исходного датасета - внесение случайной составляющей в значения входных показателей и target -----------------
-    for i in range(data_shape_0):
-        # Случайное изменение значений target
-        Delta = np.random.normal(0, abs(data_.at[i, target] * K_SKO), 1)  # MO, SKO, Кол-во
-        data_.at[i, target] = data_.at[i, target] + Delta
-        if data_.at[i, target] <= 0: data_.at[i, target] = abs(np.random.normal(0, K_SKO, 1))
-
-        # Случайное изменение значений входных показателей
-        if Delta > 0:  # Количество ошибок возросло
-            for col_1 in LOG_cols:  # Количество логирования уменьшилось
-                data_.at[i, col_1] = data_.at[i, col_1] - abs(np.random.normal(0, abs(data_.at[i, col_1]) * K_SKO, 1))
-                if data_.at[i, col_1] <= 0: data_.at[i, col_1] = abs(np.random.normal(0, K_SKO * 0.5, 1))
-            for col_2 in lack_cols:  # Количество без логирования возросло
-                data_.at[i, col_2] = data_.at[i, col_2] + abs(np.random.normal(0, abs(data_.at[i, col_2]) * K_SKO, 1))
-                if data_.at[i, col_2] <= 0: data_.at[i, col_2] = abs(np.random.normal(0, K_SKO, 1))
-        else:  # Количество ошибок уменьшилось
-            for col_1 in LOG_cols:  # Количество логирования возросло
-                data_.at[i, col_1] = data_.at[i, col_1] + abs(np.random.normal(0, abs(data_.at[i, col_1]) * K_SKO, 1))
-                if data_.at[i, col_1] <= 0: data_.at[i, col_1] = abs(np.random.normal(0, K_SKO, 1))
-            for col_2 in lack_cols:  # Количество без логирования уменьшилось
-                data_.at[i, col_2] = data_.at[i, col_2] - abs(np.random.normal(0, abs(data_.at[i, col_2]) * K_SKO, 1))
-                if data_.at[i, col_2] <= 0: data_.at[i, col_2] = abs(np.random.normal(0, K_SKO * 0.5, 1))
-
-    if j == 0: # Удаление первой строки из data
-      data = data_
-    else:   
-      data = data._append(data_)
-    data_ = copy.deepcopy(data__)
-
-#data = data.drop(0)    
-# ----------------------------------------------------------------------------------------------------------------------
-'''
-
-
-'''
-# 5.1. Генерация данных входных параметров на основе полного перебора значений с заданным шагом --------------------------------------------------------------
-# Входной файл из одной строки с нулями Logging_Error_Исходн_0.xlsx
-@njit
-def PolniPerebor_njit(data_init_np):
-    data_Max = 10000 #10000 
-    Parametr_shag = 50 #40
-    PokazKachastva_Max = 1000
-    PokazKachastva_shag = 50 #40
-    KolSluchZadaniiAnnot = 8 #12
-    KolSluchZadaniiPokazKachastva = 8 #12
-    cyclomatic_complexity_Min = 1
-    lines_of_code_Min = 3
-    nesting_depth_Min = 1
-
-    # Создаём список списков (не numpy-массивов)
-    result_data = []
-    data_ = data_init_np.copy()  # Копируем первую строку
-
-    i = Parametr_shag
-    while i <= data_Max:
-        print(i)
-        
-        for _ in range(KolSluchZadaniiAnnot):
-            Kol_Klassov = np.random.randint(i - Parametr_shag, i) # Задание количества класов в диапазоне (i - Parametr_shag, Parametr_shag)
-            if Kol_Klassov == 0: # data_[0] - markers.MON_CATCH_LOG, data_[1] - markers.MON_CATCH_LOG_LACK 
-              if np.random.rand() < 0.6:   
-                data_[1] = 1; data_[0] = 0;     
-              else: 
-                 data_[1] = 0; data_[0] = 1; 
-            else:
-              data_[0] = np.random.randint(0, Kol_Klassov); data_[1] = Kol_Klassov - data_[0]; 
-            if Kol_Klassov == 0: # data_[2] - markers.MON_TRY_LOG, data_[3] - markers.MON_TRY_LOG_LACK 
-              if np.random.rand() < 0.6:   
-                data_[3] = 1; data_[2] = 0;     
-              else: 
-                 data_[3] = 0; data_[2] = 1; 
-            else:
-              data_[2] = np.random.randint(0, Kol_Klassov); data_[3] = Kol_Klassov - data_[2]; 
-            if Kol_Klassov == 0: # data_[4] - markers.MON_COMPONENT_DEBUG, data_[5] - markers.MON_COMPONENT_LACK_DEBUG 
-              if np.random.rand() < 0.6:   
-                data_[5] = 1; data_[4] = 0;     
-              else: 
-                 data_[5] = 0; data_[4] = 1; 
-            else:
-              data_[4] = np.random.randint(0, Kol_Klassov); data_[5] = Kol_Klassov - data_[4];
-            if Kol_Klassov == 0: # data_[6] - markers.MON_COMPONENT_ERROR, data_[7] - markers.MON_COMPONENT_LACK_ERROR 
-              if np.random.rand() < 0.6:   
-                data_[7] = 1; data_[6] = 0;     
-              else: 
-                 data_[7] = 0; data_[6] = 1; 
-            else:
-              data_[6] = np.random.randint(0, Kol_Klassov); data_[7] = Kol_Klassov - data_[6];
-            if Kol_Klassov == 0: # data_[8] - markers.MON_COMPONENT_INFO, data_[9] - markers.MON_COMPONENT_LACK_INFO 
-              if np.random.rand() < 0.6:   
-                data_[9] = 1; data_[8] = 0;     
-              else: 
-                 data_[9] = 0; data_[8] = 1; 
-            else:
-              data_[8] = np.random.randint(0, Kol_Klassov); data_[9] = Kol_Klassov - data_[8];
-            if Kol_Klassov == 0: # data_[10] - markers.MON_COMPONENT_LOG, data_[11] - markers.MON_COMPONENT_LACK_LOG 
-              if np.random.rand() < 0.6:   
-                data_[11] = 1; data_[10] = 0;     
-              else: 
-                 data_[11] = 0; data_[10] = 1; 
-            else:
-              data_[10] = np.random.randint(0, Kol_Klassov); data_[11] = Kol_Klassov - data_[10];
-            if Kol_Klassov == 0: # data_[12] - markers.MON_COMPONENT_TRACE, data_[13] - markers.MON_COMPONENT_LACK_TRACE 
-              if np.random.rand() < 0.6:   
-                data_[13] = 1; data_[12] = 0;     
-              else: 
-                 data_[13] = 0; data_[12] = 1; 
-            else:
-              data_[12] = np.random.randint(0, Kol_Klassov); data_[13] = Kol_Klassov - data_[12];
-            if Kol_Klassov == 0: # data_[14] - markers.MON_COMPONENT_WARN, data_[15] - markers.MON_COMPONENT_LACK_WARN 
-              if np.random.rand() < 0.6:   
-                data_[15] = 1; data_[14] = 0;     
-              else: 
-                 data_[15] = 0; data_[14] = 1; 
-            else:
-              data_[14] = np.random.randint(0, Kol_Klassov); data_[15] = Kol_Klassov - data_[14];
-            if Kol_Klassov == 0: # data_[16] - markers.MON_CONTROLLER_DEBUG, data_[17] - markers.MON_CONTROLLER_LACK_DEBUG 
-              if np.random.rand() < 0.6:   
-                data_[17] = 1; data_[16] = 0;     
-              else: 
-                 data_[17] = 0; data_[16] = 1; 
-            else:
-              data_[16] = np.random.randint(0, Kol_Klassov); data_[17] = Kol_Klassov - data_[16];            
-            if Kol_Klassov == 0: # data_[18] - markers.MON_CONTROLLER_ERROR, data_[19] - markers.MON_CONTROLLER_LACK_ERROR 
-              if np.random.rand() < 0.6:   
-                data_[19] = 1; data_[18] = 0;     
-              else: 
-                 data_[19] = 0; data_[18] = 1; 
-            else:
-              data_[18] = np.random.randint(0, Kol_Klassov); data_[19] = Kol_Klassov - data_[18]; 
-            if Kol_Klassov == 0: # data_[20] - markers.MON_CONTROLLER_INFO, data_[21] - markers.MON_CONTROLLER_LACK_INFO 
-              if np.random.rand() < 0.6:   
-                data_[21] = 1; data_[20] = 0;     
-              else: 
-                 data_[21] = 0; data_[20] = 1; 
-            else:
-              data_[20] = np.random.randint(0, Kol_Klassov); data_[21] = Kol_Klassov - data_[20]; 
-            if Kol_Klassov == 0: # data_[22] - markers.MON_CONTROLLER_LOG, data_[23] - markers.MON_CONTROLLER_LACK_LOG 
-              if np.random.rand() < 0.6:   
-                data_[23] = 1; data_[22] = 0;     
-              else: 
-                 data_[23] = 0; data_[22] = 1; 
-            else:
-              data_[22] = np.random.randint(0, Kol_Klassov); data_[23] = Kol_Klassov - data_[22];
-            if Kol_Klassov == 0: # data_[24] - markers.MON_CONTROLLER_TRACE, data_[25] - markers.MON_CONTROLLER_LACK_TRACE 
-              if np.random.rand() < 0.6:   
-                data_[25] = 1; data_[24] = 0;     
-              else: 
-                 data_[25] = 0; data_[24] = 1; 
-            else:
-              data_[24] = np.random.randint(0, Kol_Klassov); data_[25] = Kol_Klassov - data_[24];
-            if Kol_Klassov == 0: # data_[26] - markers.MON_CONTROLLER_WARN, data_[27] - markers.MON_CONTROLLER_LACK_WARN 
-              if np.random.rand() < 0.6:   
-                data_[27] = 1; data_[26] = 0;     
-              else: 
-                 data_[27] = 0; data_[26] = 1; 
-            else:
-              data_[26] = np.random.randint(0, Kol_Klassov); data_[27] = Kol_Klassov - data_[26];
-            if Kol_Klassov == 0: # data_[28] - markers.MON_REPOSITORY_DEBUG, data_[29] - markers.MON_REPOSITORY_LACK_DEBUG 
-              if np.random.rand() < 0.6:   
-                data_[29] = 1; data_[28] = 0;     
-              else: 
-                 data_[29] = 0; data_[28] = 1; 
-            else:
-              data_[28] = np.random.randint(0, Kol_Klassov); data_[29] = Kol_Klassov - data_[28];
-            if Kol_Klassov == 0: # data_[30] - markers.MON_REPOSITORY_ERROR, data_[31] - markers.MON_REPOSITORY_LACK_ERROR 
-              if np.random.rand() < 0.6:   
-                data_[31] = 1; data_[30] = 0;     
-              else: 
-                 data_[31] = 0; data_[30] = 1; 
-            else:
-              data_[30] = np.random.randint(0, Kol_Klassov); data_[31] = Kol_Klassov - data_[30];
-            if Kol_Klassov == 0: # data_[32] - markers.MON_REPOSITORY_INFO, data_[33] - markers.MON_REPOSITORY_LACK_INFO 
-              if np.random.rand() < 0.6:   
-                data_[33] = 1; data_[32] = 0;     
-              else: 
-                 data_[33] = 0; data_[32] = 1; 
-            else:
-              data_[32] = np.random.randint(0, Kol_Klassov); data_[33] = Kol_Klassov - data_[32];
-            if Kol_Klassov == 0: # data_[34] - markers.MON_REPOSITORY_LOG, data_[35] - markers.MON_REPOSITORY_LACK_LOG 
-              if np.random.rand() < 0.6:   
-                data_[35] = 1; data_[34] = 0;     
-              else: 
-                 data_[35] = 0; data_[34] = 1; 
-            else:
-              data_[34] = np.random.randint(0, Kol_Klassov); data_[35] = Kol_Klassov - data_[34];  
-            if Kol_Klassov == 0: # data_[36] - markers.MON_REPOSITORY_TRACE, data_[37] - markers.MON_REPOSITORY_LACK_TRACE 
-              if np.random.rand() < 0.6:   
-                data_[37] = 1; data_[36] = 0;     
-              else: 
-                 data_[37] = 0; data_[36] = 1; 
-            else:
-              data_[36] = np.random.randint(0, Kol_Klassov); data_[37] = Kol_Klassov - data_[36]; 
-            if Kol_Klassov == 0: # data_[38] - markers.MON_REPOSITORY_WARN, data_[39] - markers.MON_REPOSITORY_LACK_WARN 
-              if np.random.rand() < 0.6:   
-                data_[39] = 1; data_[38] = 0;     
-              else: 
-                 data_[39] = 0; data_[38] = 1; 
-            else:
-              data_[38] = np.random.randint(0, Kol_Klassov); data_[39] = Kol_Klassov - data_[38]; 
-            if Kol_Klassov == 0: # data_[40] - markers.MON_RESTCONTROLLER_DEBUG, data_[41] - markers.MON_RESTCONTROLLER_LACK_DEBUG 
-              if np.random.rand() < 0.6:   
-                data_[41] = 1; data_[40] = 0;     
-              else: 
-                 data_[41] = 0; data_[40] = 1; 
-            else:
-              data_[40] = np.random.randint(0, Kol_Klassov); data_[41] = Kol_Klassov - data_[40]; 
-            if Kol_Klassov == 0: # data_[42] - markers.MON_RESTCONTROLLER_ERROR, data_[43] - markers.MON_RESTCONTROLLER_LACK_ERROR 
-              if np.random.rand() < 0.6:   
-                data_[43] = 1; data_[42] = 0;     
-              else: 
-                 data_[43] = 0; data_[42] = 1; 
-            else:
-              data_[42] = np.random.randint(0, Kol_Klassov); data_[43] = Kol_Klassov - data_[42];
-            if Kol_Klassov == 0: # data_[44] - markers.MON_RESTCONTROLLER_INFO, data_[45] - markers.MON_RESTCONTROLLER_LACK_INFO 
-              if np.random.rand() < 0.6:   
-                data_[45] = 1; data_[44] = 0;     
-              else: 
-                 data_[45] = 0; data_[44] = 1; 
-            else:
-              data_[44] = np.random.randint(0, Kol_Klassov); data_[45] = Kol_Klassov - data_[44];
-            if Kol_Klassov == 0: # data_[46] - markers.MON_RESTCONTROLLER_LOG, data_[47] - markers.MON_RESTCONTROLLER_LACK_LOG 
-              if np.random.rand() < 0.6:   
-                data_[47] = 1; data_[46] = 0;     
-              else: 
-                 data_[47] = 0; data_[46] = 1; 
-            else:
-              data_[46] = np.random.randint(0, Kol_Klassov); data_[47] = Kol_Klassov - data_[46];
-            if Kol_Klassov == 0: # data_[48] - markers.MON_RESTCONTROLLER_TRACE, data_[49] - markers.MON_RESTCONTROLLER_LACK_TRACE 
-              if np.random.rand() < 0.6:   
-                data_[49] = 1; data_[48] = 0;     
-              else: 
-                 data_[49] = 0; data_[48] = 1; 
-            else:
-              data_[48] = np.random.randint(0, Kol_Klassov); data_[49] = Kol_Klassov - data_[48];
-            if Kol_Klassov == 0: # data_[50] - markers.MON_RESTCONTROLLER_WARN, data_[51] - markers.MON_RESTCONTROLLER_LACK_WARN 
-              if np.random.rand() < 0.6:   
-                data_[51] = 1; data_[50] = 0;     
-              else: 
-                 data_[51] = 0; data_[50] = 1; 
-            else:
-              data_[50] = np.random.randint(0, Kol_Klassov); data_[51] = Kol_Klassov - data_[50];
-            if Kol_Klassov == 0: # data_[52] - markers.MON_SERVICE_DEBUG, data_[53] - markers.MON_SERVICE_LACK_DEBUG 
-              if np.random.rand() < 0.6:   
-                data_[52] = 1; data_[52] = 0;     
-              else: 
-                 data_[52] = 0; data_[52] = 1; 
-            else:
-              data_[52] = np.random.randint(0, Kol_Klassov); data_[53] = Kol_Klassov - data_[52];
-            if Kol_Klassov == 0: # data_[54] - markers.MON_SERVICE_ERROR, data_[55] - markers.MON_SERVICE_LACK_ERROR 
-              if np.random.rand() < 0.6:   
-                data_[55] = 1; data_[54] = 0;     
-              else: 
-                 data_[55] = 0; data_[54] = 1; 
-            else:
-              data_[54] = np.random.randint(0, Kol_Klassov); data_[55] = Kol_Klassov - data_[54];
-            if Kol_Klassov == 0: # data_[56] - markers.MON_SERVICE_INFO, data_[57] - markers.MON_SERVICE_LACK_INFO 
-              if np.random.rand() < 0.6:   
-                data_[57] = 1; data_[56] = 0;     
-              else: 
-                 data_[57] = 0; data_[56] = 1; 
-            else:
-              data_[56] = np.random.randint(0, Kol_Klassov); data_[57] = Kol_Klassov - data_[56]; 
-            if Kol_Klassov == 0: # data_[58] - markers.MON_SERVICE_LOG, data_[59] - markers.MON_SERVICE_LACK_LOG 
-              if np.random.rand() < 0.6:   
-                data_[59] = 1; data_[58] = 0;     
-              else: 
-                 data_[59] = 0; data_[58] = 1; 
-            else:
-              data_[58] = np.random.randint(0, Kol_Klassov); data_[59] = Kol_Klassov - data_[58]; 
-            if Kol_Klassov == 0: # data_[60] - markers.MON_SERVICE_TRACE, data_[61] - markers.MON_SERVICE_LACK_TRACE 
-              if np.random.rand() < 0.6:   
-                data_[61] = 1; data_[60] = 0;     
-              else: 
-                 data_[61] = 0; data_[60] = 1; 
-            else:
-              data_[60] = np.random.randint(0, Kol_Klassov); data_[61] = Kol_Klassov - data_[60];
-            if Kol_Klassov == 0: # data_[62] - markers.MON_SERVICE_WARN, data_[63] - markers.MON_SERVICE_LACK_WARN 
-              if np.random.rand() < 0.6:   
-                data_[63] = 1; data_[62] = 0;     
-              else: 
-                 data_[63] = 0; data_[62] = 1; 
-            else:
-              data_[62] = np.random.randint(0, Kol_Klassov); data_[63] = Kol_Klassov - data_[62];
-
-            j = PokazKachastva_shag
-            while j <= PokazKachastva_Max:
-                for __ in range(KolSluchZadaniiPokazKachastva):
-                    aa = random.uniform(0, j)
-                    if aa < cyclomatic_complexity_Min: aa = cyclomatic_complexity_Min
-                    data_[64] = aa                        # cyclomatic_complexity_LACK
-                    bb = random.uniform(2, 5)
-                    aa = aa * bb
-                    if aa < lines_of_code_Min: aa = lines_of_code_Min
-                    data_[65] = aa                        # lines_of_code_LACK
-                    data_[66] = random.uniform(0, j / 10) # lambda_count_LACK
-                    aa = random.uniform(0, j / 2)
-                    if aa < nesting_depth_Min: aa = nesting_depth_Min
-                    data_[67] = aa                        # nesting_depth_LACK
-                    data_[68] = random.uniform(0, j / 10) # try_catch_count_LACK
-                    
-                    # Вручную преобразуем массив в список (без .tolist())
-                    row_list = [data_[k] for k in range(len(data_))]
-                    result_data.append(row_list)
-                
-                j += PokazKachastva_shag
-
-        i += Parametr_shag
-
-    return result_data
-
-# Подготовка данных перед вызовом njit-функции
-# columns = [
-#     'markers.MON_CATCH_LOG', 'markers.MON_CATCH_LOG_LACK', 'markers.MON_TRY_LOG', 'markers.MON_TRY_LOG_LACK', 'markers.MON_COMPONENT_DEBUG',
-#     'markers.MON_COMPONENT_LACK_DEBUG', 'markers.MON_COMPONENT_ERROR', 'markers.MON_COMPONENT_LACK_ERROR', 'markers.MON_COMPONENT_INFO',
-#     'markers.MON_COMPONENT_LACK_INFO', 'markers.MON_COMPONENT_LOG', 'markers.MON_COMPONENT_LACK_LOG', 'markers.MON_COMPONENT_TRACE',
-#     'markers.MON_COMPONENT_LACK_TRACE', 'markers.MON_COMPONENT_WARN', 'markers.MON_COMPONENT_LACK_WARN', 'markers.MON_CONTROLLER_DEBUG',
-#     'markers.MON_CONTROLLER_LACK_DEBUG', 'markers.MON_CONTROLLER_ERROR', 'markers.MON_CONTROLLER_LACK_ERROR', 'markers.MON_CONTROLLER_INFO',
-#     'markers.MON_CONTROLLER_LACK_INFO', 'markers.MON_CONTROLLER_LOG', 'markers.MON_CONTROLLER_LACK_LOG', 'markers.MON_CONTROLLER_TRACE',
-#     'markers.MON_CONTROLLER_LACK_TRACE', 'markers.MON_CONTROLLER_WARN', 'markers.MON_CONTROLLER_LACK_WARN', 'markers.MON_REPOSITORY_DEBUG',
-#     'markers.MON_REPOSITORY_LACK_DEBUG', 'markers.MON_REPOSITORY_ERROR', 'markers.MON_REPOSITORY_LACK_ERROR', 'markers.MON_REPOSITORY_INFO',
-#     'markers.MON_REPOSITORY_LACK_INFO', 'markers.MON_REPOSITORY_LOG', 'markers.MON_REPOSITORY_LACK_LOG', 'markers.MON_REPOSITORY_TRACE',
-#     'markers.MON_REPOSITORY_LACK_TRACE', 'markers.MON_REPOSITORY_WARN', 'markers.MON_REPOSITORY_LACK_WARN', 'markers.MON_RESTCONTROLLER_DEBUG',
-#     'markers.MON_RESTCONTROLLER_LACK_DEBUG', 'markers.MON_RESTCONTROLLER_ERROR', 'markers.MON_RESTCONTROLLER_LACK_ERROR', 'markers.MON_RESTCONTROLLER_INFO',
-#     'markers.MON_RESTCONTROLLER_LACK_INFO', 'markers.MON_RESTCONTROLLER_LOG', 'markers.MON_RESTCONTROLLER_LACK_LOG', 'markers.MON_RESTCONTROLLER_TRACE',
-#     'markers.MON_RESTCONTROLLER_LACK_TRACE', 'markers.MON_RESTCONTROLLER_WARN', 'markers.MON_RESTCONTROLLER_LACK_WARN', 'markers.MON_SERVICE_DEBUG',
-#     'markers.MON_SERVICE_LACK_DEBUG', 'markers.MON_SERVICE_ERROR', 'markers.MON_SERVICE_LACK_ERROR', 'markers.MON_SERVICE_INFO',
-#     'markers.MON_SERVICE_LACK_INFO', 'markers.MON_SERVICE_LOG', 'markers.MON_SERVICE_LACK_LOG', 'markers.MON_SERVICE_TRACE', 'markers.MON_SERVICE_LACK_TRACE',
-#     'markers.MON_SERVICE_WARN', 'markers.MON_SERVICE_LACK_WARN', 'markers.cyclomatic_complexity_LACK', 'markers.lines_of_code_LACK',	
-#     'markers.lambda_count_LACK', 'markers.nesting_depth_LACK', 'markers.try_catch_count_LACK' 'target'
-#  ]
-columns = data.columns.tolist()
-
-# Берём первую строку исходного DataFrame и конвертируем в numpy
-data_init_np = data.iloc[0].to_numpy()
-
-# Вызываем Numba-функцию
-result_data = PolniPerebor_njit(data_init_np)
-
-# Конвертируем результат в numpy-массив и удаляем строки с cyclomatic_complexity_lack == 0
-result_np = np.array(result_data)
-mask = result_np[:, 18] != 0
-result_np = result_np[mask]
-
-# Конвертируем обратно в DataFrame
-data = pd.DataFrame(result_np, columns=columns)  
-# --------------------------------------------------------------------------------------------------------------------------------------------
-'''
-
-
-
-
-
-'''
-# 2.1, 2.2. Генерация данных LOG, lack и target на основе перебора значений с заданным шагом --------------------------------------------------------------
-def Gener_LOG_lack_target(data_data, Name_LOG, Name_LOG_lack, LOG_max, LOG_shag, target_max):
-    data_ = copy.deepcopy(data_data.iloc[0]) # Извлечение из датафрейма первой строки
-
-    if Name_LOG != '': # Если есть данные с LOG и с lack
-
-        i = 0
-        while i <= LOG_max: # Количество LOG
-
-            k = 0
-            while k <= LOG_max: # Количество LOG_lack
-
-                if i + k > LOG_max:
-                    k = LOG_max
-                else:
-                    if i + k != 0:
-                        data_[Name_LOG] = i
-                        data_[Name_LOG_lack] = k
-
-                        summa = (i / (i + k))
-                        targ = -(target_max - target_min) * summa + target_max
-                        targ = targ * (2.5e-4 * k + 0.9997498749) # targ * [от 1 - до 1.5] # При i == 0 и одинаковом index: terg тем больше, чем больше k
-
-                        if k == 0: # Множитель при Name_LOG_lack = 0
-                            targ = targ * (-5.0e-4 * i + 2.0) # targ * [от 1 - до 2]
-
-                        data_[target] = targ
-
-                        data_data = data_data._append(data_)
-
-                k += LOG_shag
-
-            i += LOG_shag
-
-    else: # Если нет данных с LOG, есть только с lack
-
-        i = 0
-        while i <= LOG_max: # Количество LOG_lack
-
-            data_[Name_LOG_lack] = i
-
-            # if i > 0:
-            #     targ = data_Min + ((target_max - data_Min) * i) / LOG_max - LOG_shag / i
-            # else:
-            #     targ = data_Min + ((target_max - data_Min) * i) / LOG_max  
-
-            targ = data_Min + ((target_max - data_Min) * i) / LOG_max
-
-            data_[target] = targ
-
-            data_data = data_data._append(data_)
-
-            i += LOG_shag
-
-    return data_data
-
-
-data__ = copy.deepcopy(data)
-
-# LOG_max = data_Max; LOG_shag = 10; target_max = 60; target_min = target_min
-
-data_gen = Gener_LOG_lack_target(data__, 'bean', 'bean_lack', LOG_max=data_Max, LOG_shag=50, target_max=700)
-data = data._append(data_gen); print(1)
-data_gen = Gener_LOG_lack_target(data__, 'component', 'component_lack', LOG_max=data_Max, LOG_shag=50, target_max=300)
-data = data._append(data_gen); print(2)
-data_gen = Gener_LOG_lack_target(data__, 'config', 'config_lack', LOG_max=data_Max, LOG_shag=50, target_max=700)
-data = data._append(data_gen); print(3)
-data_gen = Gener_LOG_lack_target(data__, 'controller', 'controller_lack', LOG_max=data_Max, LOG_shag=50, target_max=500)
-data = data._append(data_gen); print(4)
-data_gen = Gener_LOG_lack_target(data__, 'entity', 'entity_lack', LOG_max=data_Max, LOG_shag=50, target_max=500)
-data = data._append(data_gen); print(5)
-data_gen = Gener_LOG_lack_target(data__, 'repository', 'repository_lack', LOG_max=data_Max, LOG_shag=50, target_max=1000)
-data = data._append(data_gen); print(6)
-data_gen = Gener_LOG_lack_target(data__, 'service', 'service_lack', LOG_max=data_Max, LOG_shag=50, target_max=1200)
-data = data._append(data_gen); print(7)
-data_gen = Gener_LOG_lack_target(data__, 'interface', 'interface_lack', LOG_max=data_Max, LOG_shag=50, target_max=500)
-data = data._append(data_gen); print(8)
-data_gen = Gener_LOG_lack_target(data__, 'interfimps', 'interfimps_lack', LOG_max=data_Max, LOG_shag=50, target_max=500)
-data = data._append(data_gen); print(9)
-
-data_gen = Gener_LOG_lack_target(data__, '', 'cyclomatic_complexity_lack', LOG_max=data_Max, LOG_shag=50, target_max=1300)
-data = data._append(data_gen); print(10)
-data_gen = Gener_LOG_lack_target(data__, '', 'lines_of_code_lack', LOG_max=data_Max, LOG_shag=50, target_max=1000)
-data = data._append(data_gen); print(11)
-data_gen = Gener_LOG_lack_target(data__, '', 'lambda_count_lack', LOG_max=data_Max, LOG_shag=50, target_max=500)
-data = data._append(data_gen); print(12)
-data_gen = Gener_LOG_lack_target(data__, '', 'nesting_depth_lack', LOG_max=data_Max, LOG_shag=50, target_max=800)
-data = data._append(data_gen); print(13)
-data_gen = Gener_LOG_lack_target(data__, '', 'try_catch_count_lack', LOG_max=data_Max, LOG_shag=50, target_max=500)
-data = data._append(data_gen); print(14)
-# ----------------------------------------------------------------------------------------------------------------------------------------------------------
-'''
-
-
-'''
-data = data.drop_duplicates(keep=False)
-
-# Удаление индексов строк из датафрейма
-data = data.reset_index(drop=True)
-print('data.shape = ', data.shape)
-
-
-# Удаление дублирующихся строк, оставлены первые вхождения
-data = data.drop_duplicates(subset=num_features)
-print('data.shape = ', data.shape)
-
-# Удаление строк из data не удовлетворяющих условиям: < data_Max и >= data_Min
-#data = data.loc[data[target] < data_Max]
-#data = data.loc[data[target] >= data_Min]
-#for col in num_features:
-#    data = data.loc[data[col] < data_Max]
-#print('data.shape = ', data.shape)
-
-# Сохранение модифицированного датасета в файл
-data.to_excel('Logging_Error_.xlsx', index=False)
-print('Файл сохранён.')
-'''
-
-
-
-
-
-
-'''
-# 3.1. Увеличение количества строк в датасете на основе случайного изменения исходного датасета --------------------------------------
-def Gener_LOG_lack(Name_LOG, Name_LOG_lack, j):
-    
-    a = data_.at[j, Name_LOG]
-    if (a == 0) and (np.random.random() >= 0.5): a = data_Min
-    a = abs(np.random.normal(a, a * SKO_random_normal, 1))
-    if a > data_Max: a = data_Max - 1
-    b = data_.at[j, Name_LOG_lack]
-    if (b == 0) and (np.random.random() >= 0.5): b = data_Min
-    b = abs(np.random.normal(b, b * SKO_random_normal, 1))
-    if b > data_Max: d = data_Max - 1
-    data_.at[j, Name_LOG] = a
-    data_.at[j, Name_LOG_lack] = b
-
-    return data_.at[j, Name_LOG], data_.at[j, Name_LOG_lack]
-
-def Gener_lack(Name_LOG_lack, j):
-    
-    b = data_.at[j, Name_LOG_lack]
-    if (b == 0) and (np.random.random() >= 0.5): b = data_Min
-    b = abs(np.random.normal(b, b * SKO_random_normal, 1))
-    if b > data_Max: d = data_Max - 1
-    data_.at[j, Name_LOG_lack] = b
-
-    return data_.at[j, Name_LOG_lack]    
-
-data_ = copy.deepcopy(data)
-data__ = copy.deepcopy(data)
-
-np.random.seed(0)
-data_shape_0 = data.shape[0]
-
-for i in range(num_increment_cycles):
-    print(i)
-
-    for j in range(data_shape_0):
-
-        data_.at[j, 'bean'], data_.at[j, 'bean_lack'] = Gener_LOG_lack('bean', 'bean_lack', j)
-        data_.at[j, 'component'], data_.at[j, 'component_lack'] = Gener_LOG_lack('component', 'component_lack', j)
-        data_.at[j, 'config'], data_.at[j, 'config_lack'] = Gener_LOG_lack('config', 'config_lack', j)
-        data_.at[j, 'controller'], data_.at[j, 'controller_lack'] = Gener_LOG_lack('controller', 'controller_lack', j)
-        data_.at[j, 'entity'], data_.at[j, 'entity_lack'] = Gener_LOG_lack('entity', 'entity_lack', j)
-        data_.at[j, 'repository'], data_.at[j, 'repository_lack'] = Gener_LOG_lack('repository', 'repository_lack', j)
-        data_.at[j, 'service'], data_.at[j, 'service_lack'] = Gener_LOG_lack('service', 'service_lack', j)
-        data_.at[j, 'interface'], data_.at[j, 'interface_lack'] = Gener_LOG_lack('interface', 'interface_lack', j)
-        data_.at[j, 'interfimps'], data_.at[j, 'interfimps_lack'] = Gener_LOG_lack('interfimps', 'interfimps_lack', j)
-
-        data_.at[j, 'cyclomatic_complexity_lack'] = Gener_lack('cyclomatic_complexity_lack', j)
-        data_.at[j, 'lines_of_code_lack'] = Gener_lack('lines_of_code_lack', j)
-        data_.at[j, 'lambda_count_lack'] = Gener_lack('lambda_count_lack', j)
-        data_.at[j, 'nesting_depth_lack'] = Gener_lack('nesting_depth_lack', j)
-        data_.at[j, 'try_catch_count_lack'] = Gener_lack('try_catch_count_lack', j)
-
-        #data_.at[j, 'target'] = Gener_lack('target', j)
-
-    data = data._append(data_)
-    data_ = copy.deepcopy(data__)
-# ----------------------------------------------------------------------------------------------------------------------
-'''
-
-
-'''
-# 3.2, 5.2. Вычисление количества ошибок (target) на основе количества и соотношения LOG, lack в реальных данных ---------------------------------
-@njit
-def Gener_target_njit(data_np, columns_idx, Name_LOG, Name_LOG_lack, target_min, target_max, j):
-    targ = 0.0
-    
-    if Name_LOG != '':  # Если есть данные с LOG и с lack
-        i_idx = columns_idx[Name_LOG]
-        k_idx = columns_idx[Name_LOG_lack]
-        i = data_np[j, i_idx]
-        k = data_np[j, k_idx]
-        
-        if i + k != 0:
-            index = i / (i + k)
-            targ = -(target_max - target_min) * index + target_max
-            targ = targ * (2.5e-4 * k + 0.9997498749) # targ * [от 1 - до 1.5] # При i == 0 и одинаковом index: terg тем больше, чем больше k
-            if k == 0:
-                targ = targ * (-5.0e-4 * i + 2.0)
-    else:  # Если нет данных с LOG, есть только с lack
-        k_idx = columns_idx[Name_LOG_lack]
-        i = data_np[j, k_idx]
-        targ = data_Min + ((target_max - data_Min) * i) / data_Max
-        
-    return targ
-
-@njit
-def Opred_target_njit(data_np, columns_idx, target_idx):
-    target_min = 1
-    np.random.seed(0)
-    data_shape_0 = data_np.shape[0]
-    
-    for j in range(data_shape_0):
-        if j % 5000 == 0: 
-            print(j)
-        
-        target_summ = 0.0
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_CATCH_LOG', 'markers.MON_CATCH_LOG_LACK', target_min, 125, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_TRY_LOG', 'markers.MON_TRY_LOG_LACK', target_min, 125, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_COMPONENT_DEBUG', 'markers.MON_COMPONENT_LACK_DEBUG', target_min, 120, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_COMPONENT_ERROR', 'markers.MON_COMPONENT_LACK_ERROR', target_min, 125, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_COMPONENT_INFO', 'markers.MON_COMPONENT_LACK_INFO', target_min, 110, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_COMPONENT_LOG', 'markers.MON_COMPONENT_LACK_LOG', target_min, 115, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_COMPONENT_TRACE', 'markers.MON_COMPONENT_LACK_TRACE', target_min, 105, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_COMPONENT_WARN', 'markers.MON_COMPONENT_LACK_WARN', target_min, 110, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_CONTROLLER_DEBUG', 'markers.MON_CONTROLLER_LACK_DEBUG', target_min, 120, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_CONTROLLER_ERROR', 'markers.MON_CONTROLLER_LACK_ERROR', target_min, 125, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_CONTROLLER_INFO', 'markers.MON_CONTROLLER_LACK_INFO', target_min, 100, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_CONTROLLER_LOG', 'markers.MON_CONTROLLER_LACK_LOG', target_min, 115, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_CONTROLLER_TRACE', 'markers.MON_CONTROLLER_LACK_TRACE', target_min, 105, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_CONTROLLER_WARN', 'markers.MON_CONTROLLER_LACK_WARN', target_min, 110, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_REPOSITORY_DEBUG', 'markers.MON_REPOSITORY_LACK_DEBUG', target_min, 115, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_REPOSITORY_ERROR', 'markers.MON_REPOSITORY_LACK_ERROR', target_min, 120, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_REPOSITORY_INFO', 'markers.MON_REPOSITORY_LACK_INFO', target_min, 95, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_REPOSITORY_LOG', 'markers.MON_REPOSITORY_LACK_LOG', target_min, 110, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_REPOSITORY_TRACE', 'markers.MON_REPOSITORY_LACK_TRACE', target_min, 100, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_REPOSITORY_WARN', 'markers.MON_REPOSITORY_LACK_WARN', target_min, 105, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_RESTCONTROLLER_DEBUG', 'markers.MON_RESTCONTROLLER_LACK_DEBUG', target_min, 115, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_RESTCONTROLLER_ERROR', 'markers.MON_RESTCONTROLLER_LACK_ERROR', target_min, 120, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_RESTCONTROLLER_INFO', 'markers.MON_RESTCONTROLLER_LACK_INFO', target_min, 95, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_RESTCONTROLLER_LOG', 'markers.MON_RESTCONTROLLER_LACK_LOG', target_min, 110, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_RESTCONTROLLER_TRACE', 'markers.MON_RESTCONTROLLER_LACK_TRACE', target_min, 100, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_RESTCONTROLLER_WARN', 'markers.MON_RESTCONTROLLER_LACK_WARN', target_min, 105, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_SERVICE_DEBUG', 'markers.MON_SERVICE_LACK_DEBUG', target_min, 110, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_SERVICE_ERROR', 'markers.MON_SERVICE_LACK_ERROR', target_min, 115, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_SERVICE_INFO', 'markers.MON_SERVICE_LACK_INFO', target_min, 90, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_SERVICE_LOG', 'markers.MON_SERVICE_LACK_LOG', target_min, 105, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_SERVICE_TRACE', 'markers.MON_SERVICE_LACK_TRACE', target_min, 95, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, 'markers.MON_SERVICE_WARN', 'markers.MON_SERVICE_LACK_WARN', target_min, 100, j) 
-
-        target_summ += Gener_target_njit(data_np, columns_idx, '', 'markers.cyclomatic_complexity_LACK', target_min, 300, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, '', 'markers.lines_of_code_LACK', target_min, 250, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, '', 'markers.lambda_count_LACK', target_min, 100, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, '', 'markers.nesting_depth_LACK', target_min, 150, j)
-        target_summ += Gener_target_njit(data_np, columns_idx, '', 'markers.try_catch_count_LACK', target_min, 100, j)
-        
-        data_np[j, target_idx] = target_summ
-    
-    return data_np
-
-# Подготовка данных перед вызовом функций
-columns = data.columns.tolist()
-
-# Создаем Numba-совместимый словарь (исправленная версия)
-columns_idx = Dict.empty(
-    key_type=types.unicode_type,  # Используем unicode_type вместо unicode_string
-    value_type=types.int64
-)
-for idx, col in enumerate(columns):
-    columns_idx[col] = idx
-
-target_idx = columns_idx['target']
-
-# Конвертируем DataFrame в numpy array
-data_np = data.to_numpy().astype(np.float64)  # Явно указываем тип float64 для Numba
-
-# Вызываем Numba-функцию
-result_np = Opred_target_njit(data_np, columns_idx, target_idx)
-
-# Конвертируем обратно в DataFrame
-data = pd.DataFrame(result_np, columns=columns)
-# -------------------------------------------------------------------------------------------------------------------------------------------
-'''
-
-
-
-
-
-
-'''
-# Удаление дублирующихся строк, оставлены первые вхождения
-data = data.drop_duplicates(subset=num_features)
-print('data.shape = ', data.shape)
-
-# Удаление строк из data не удовлетворяющих условиям: < data_Max и >= data_Min
-#data = data.loc[data[target] < data_Max]
-#data = data.loc[data[target] >= data_Min]
-#for col in num_features:
-#    data = data.loc[data[col] < data_Max]
-#print('data.shape = ', data.shape)
-
-# Сохранение модифицированного датасета в файл
-data.to_excel('Logging_Error_.xlsx', index=False)
-print('Файл сохранён.')
-
-
-# Чтение данных
-data = pd.read_excel('Logging_Error_.xlsx')
-data = data.astype(float)
-data.shape
-print('Данные загружены, data.shape = ', data.shape)
-'''
-
-
-
-
-
-'''
-# Чтение данных
-data = pd.read_excel('Logging_Error_.xlsx')
-data = data.astype(float)
-data.shape
-print('Данные загружены, data.shape = ', data.shape)
-'''
-
-
-
-
-# 2.3, 3.3, 5.3. Зашумление исходного датасета - внесение случайной составляющей в значения входных показателей и target -----
-# Без увеличения количества строк в датасете
-@njit
-def Zashumlenie_njit(data_np, target_idx, LOG_cols_idx, LACK_cols_idx):
-    K_SKO=0.0001
-    np.random.seed(0)
-    data_shape_0 = data_np.shape[0]
-    
-    for i in range(data_shape_0):
-        if i % 5000 == 0: print(i)
-        
-        # Обработка target
-        Delta = np.random.normal(0, abs(data_np[i, target_idx] * K_SKO))
-        data_np[i, target_idx] += Delta
-        if data_np[i, target_idx] <= 0: 
-            data_np[i, target_idx] = abs(np.random.normal(0, K_SKO))
-        
-        if Delta > 0:  # Ошибки возросли
-            for col_idx in LOG_cols_idx:  # Уменьшаем логирование
-                delta = abs(np.random.normal(0, abs(data_np[i, col_idx] * K_SKO)))
-                data_np[i, col_idx] -= delta
-                if data_np[i, col_idx] <= 0:
-                    data_np[i, col_idx] = abs(np.random.normal(0, K_SKO * 0.5))
-            for col_idx in LACK_cols_idx:  # Увеличиваем отсутствие логирования
-                delta = abs(np.random.normal(0, abs(data_np[i, col_idx] * K_SKO)))
-                data_np[i, col_idx] += delta
-                if data_np[i, col_idx] <= 0:
-                    data_np[i, col_idx] = abs(np.random.normal(0, K_SKO))
-        else:  # Ошибки уменьшились
-            for col_idx in LOG_cols_idx:  # Увеличиваем логирование
-                delta = abs(np.random.normal(0, abs(data_np[i, col_idx] * K_SKO)))
-                data_np[i, col_idx] += delta
-                if data_np[i, col_idx] <= 0:
-                    data_np[i, col_idx] = abs(np.random.normal(0, K_SKO))
-            for col_idx in LACK_cols_idx:  # Уменьшаем отсутствие логирования
-                delta = abs(np.random.normal(0, abs(data_np[i, col_idx] * K_SKO)))
-                data_np[i, col_idx] -= delta
-                if data_np[i, col_idx] <= 0:
-                    data_np[i, col_idx] = abs(np.random.normal(0, K_SKO * 0.5))
-    
-    return data_np
-
-# Подготовка данных перед вызовом функции
-columns = data.columns.tolist()
-num_features = [col for col in columns if col != 'target']
-LACK_cols = [x for x in num_features if '_LACK' in x]
-LOG_cols = [x for x in num_features if not '_LACK' in x]
-
-# Получаем индексы колонок
-target_idx = columns.index('target')
-LOG_cols_idx = [columns.index(col) for col in LOG_cols]
-LACK_cols_idx = [columns.index(col) for col in LACK_cols]
-
-# Конвертируем DataFrame в numpy array
-data_np = data.to_numpy()
-
-# Вызываем Numba-функцию
-result_np = Zashumlenie_njit(data_np, target_idx, LOG_cols_idx, LACK_cols_idx)
-
-# Конвертируем обратно в DataFrame
-data = pd.DataFrame(result_np, columns=columns)
-#-------------------------------------------------------------------------------------------------------------------------
-
-
-
-
-
-
-# Умножение на число ------------------------------------------------------------------------------------------------
-#data = data / 10
-# -------------------------------------------------------------------------------------------------------------------
-
-
-# Удаление дублирующихся строк, оставлены первые вхождения
-data = data.drop_duplicates(subset=num_features)
-print('data.shape = ', data.shape)
-
-# Удаление строк из data не удовлетворяющих условиям: < data_Max и >= data_Min
-data = data.loc[data[target] < data_Max]
-#data = data.loc[data[target] >= data_Min]
-for col in num_features:
-    data = data.loc[data[col] < data_Max]
-data.shape
-print('Удаление строк из data не удовлетворяющих условиям: < data_Max и >= data_Min')
-print('data.shape = ', data.shape)
-
-# Сохранение модифицированного датасета в файл
-#data.to_excel('Logging_Error_.xlsx', index=False)
-data.to_excel(data_save_path, index=False)
-print('Файл сохранён.')
-
-
-
-
-'''
-# Многомерный анализ и определение корреляций --------------------------------------------------------------------------
-correl = data.corr()
-cmap = sb.diverging_palette(220, 10, as_cmap = True)
-
-mask = np.zeros_like(correl, dtype = np.bool_)
-mask[np.triu_indices_from(mask)] = True
-
-f, ax = plt.subplots(figsize = (30, 30))
-
-sb.heatmap(correl, mask = mask, cmap = cmap, vmax = 0.9, center = 0, annot = True, square = True, linewidths = 0.2, cbar_kws = {"shrink": .5});
-# ----------------------------------------------------------------------------------------------------------------------
-
-from sklearn.model_selection import train_test_split
-# разбиение на признаки и целевую переменную
-X = data.drop(columns=[target])
-y = data[target]
-print('X.shape = ', X.shape,' y.shape = ', y.shape)
-#print(y)
-
-# заполнение пропусков
-strategy = 'median'
-nan_cols = X.columns[X.isna().any()].tolist()
-for col in nan_cols:
-    #print(col)
-    imputer = SimpleImputer(strategy=strategy)
-    X[col] = imputer.fit_transform(np.array(X[col]).reshape(-1, 1))
-    print(X[col])
-
-# Преобразование X и y в массив numpy
-X, y = np.array(X), np.array(y)
-
-# # Ограничение выбросов в данных
-# for i in range(X.shape[0]):
-#     for j in range(X.shape[1]):
-#         if X[i][j] > X_max: X[i][j] = X_max + np.random.normal(0, SKO_random_normal, 1)  # MO, SKO, Кол-во
-
-# for i in range(y.shape[0]):
-#     if y[i] > y_max: y[i] = y_max + np.random.normal(0, SKO_random_normal, 1)  # MO, SKO, Кол-во
-
-# Визуализация входных данных модели -------------------------------------------------------------------------------------
-plt.figure(figsize = (18,7))
-#for i in range(10):
-for i in range(len(X)):
-  plt.plot(X[i])
-plt.show()
-plt.close()
-
-# Визуализация целевых данных
-plt.figure(figsize = (18,7))
-#plt.plot(y[:100])
-plt.plot(y)
-plt.show()
-plt.close()
-
-# Визуализация столбцов входных данных модели X_train
-X_t = X.reshape(-1, X.shape[0])
-# print('X_t.shape: ', X_t.shape)
-plt.figure(figsize = (18,10))
-for i in range(X_t.shape[0]):
-  plt.plot(X_t[i])
-# plt.subplot(611)
-# plt.plot(X_t[0])
-plt.show()
-plt.close()
-'''
-
-
-
-
-
-# # Проверка качества модели на реальных (не синтезированных данных)
-# # Загрузка готовой модели из файла или папки
-# #*************************************************************************************************************
-# model_name = 'Model_Logging_Error_LSTM_30102024.keras'
-# print()
-# print('Загрузка готовой модели из файла\n')
-# model_ = keras.models.load_model(model_name)
-# #model.summary()
-
-# #model_ = model
-
-# # Прогнозирование - тестирование качества модели на тестовых данных ************************************************************
-# max_y = data_Max
-# max_X = data_Max
-# Dobavka = 0
-
-# X_test = X / max_X
-# y_test = y
-
-# predictions = model_.predict(X_test)
-
-# # Возврат масштабированных прогнозных данных обратно к их фактическим значениям.
-# # y_test = y_test.reshape(-1, 1)
-# # y_test = scaler_y.inverse_transform(y_test)
-# # predictions = scaler_y.inverse_transform(predictions)
-# predictions = predictions * max_y
-# predictions = predictions - Dobavka
-
-# # Не должно быть отрицательных значений
-# for i in range(len(predictions)):
-#     if predictions[i] < 0: predictions[i] = 0
-# #print('y = ', predictions)
-
-# def print_result_regression(y_true, y_pred):
-#     r2 = r2_score(y_true, y_pred)
-#     mae = mean_absolute_error(y_true, y_pred)
-#     rmse = mean_squared_error(y_true, y_pred)**0.5
-#     print(f'''
-# r2:   {r2:.4f}
-# mae:  {mae:.4f}
-# rmse: {rmse:.4f}
-#      ''')
-#     return f'{r2:.4f}',f'{mae:.4f}',f'{rmse:.4f}'
-
-# # Контроль показателей качества работы модели по тестовой выборке
-# r2, mae, rmse = print_result_regression(y_test, predictions)
-
-# # Вывод нескольких последних значений цели и прогноза
-# print('   Цель     Прогноз   Отклонение')
-# for i in range(len(predictions)-30, len(predictions)):
-#     print(f''' {y_test[i]:8.4f}  {predictions[i][0]:8.4f}  {abs(y_test[i] - predictions[i][0]):8.4f} ''')
-