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

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

@@ -0,0 +1,957 @@
+# Модель связывает организацию кода в части использования разных программных модулей для разных архитектурных элементов (маркированных классов)
+# с количеством фиксируемых ошибок в работе кода.
+# Анализ данных, синтез данных.
+
+# Метолика использования.
+# Удаление строк из data не удовлетворяющих условиям: < data_Max и >= data_Min
+# Удаление дублирующихся строк, оставлены первые вхождения
+# Заполнение пустых ячеек нулевыми значениями, если нужно
+# 0. Увеличение количества СТОЛБЦОВ датасета, если нужно ???
+# 1. Генерация нулевых значений данных (из одной строки с нулями - файл Modules_Error_Исходн_0.xlsx).
+# 1.1. Сгенерировать нулевые значения входных параметров.
+# 1.2. Сгенерировать нулевые значения выходов - target.
+# 1.3. Зашумить данные нормальным шумом с K_SKO = 0.0001 - выходной файл Modules_Error_0.xlsx. 
+# 2. Генерация значений входных параметров с заданным шагом.
+# 2.1. Сгенерировать значения входных параметров с заданным шагом - входной файл из одной строки с нулями Modules_Error_Исходн_0.xlsx.
+# 2.2. Вычислить значения выходов - target - выходной файл Modules_Error_перебор_значений_0.xlsx.
+# 2.3. Зашумить данные нормальным шумом с K_SKO = 0.0001 - выходной файл Modules_Error_перебор_значений_шум.xlsx.
+# 3. Генерация значений входных параметров на основе реальных данных.
+# 3.1. Увеличение количества строк в датасете на основе случайного изменения исходного датасета - входной файл Modules_Error_Исходн_Синт.xlsx.
+# 3.2. Вычислить значения выходов - target - входной файл Modules_Error_увел_исходн.xlsx, выходной - Modules_Error_увел_исходн_target.xlsx.
+# 3.3. Зашумить данные нормальным шумом с K_SKO = 0.0001 - выходной файл Modules_Error_шум_исходн_target.xlsx.
+# 4. Объединить все сгенерированные данные в один файл - итоговый файл Modules_Error_Синтетические.xlsx.
+
+# 5. Генерация данных на основе полного перебора значений с заданным шагом
+# 5.1. Генерация данных входных параметров на основе полного перебора значений с заданным шагом - входной файл из одной строки с нулями Modules_Error_Исходн_0.xlsx.
+# 5.2. 3.2. Вычисление количества ошибок (target) на основе количества и соотношения LOG, lack - входной файл Modules_Error_увел_исходн.xlsx, выходной - Modules_Error_увел_исходн_target.xlsx.
+# 5.3. 3.3. Зашумить данные нормальным шумом с K_SKO = 0.0001 - выходной файл Modules_Error_шум_исходн_target.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')
+
+# Параметры модели ------------------------------------------------------------------------------
+model_name = 'Model_Modules_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 = [
+    'bean',	
+    'bean_lack',	
+    'component',	
+    'component_lack',	
+    'config',	
+    'config_lack',	
+    'controller',	
+    'controller_lack',	
+    'entity',	
+    'entity_lack',	
+    'repository',	
+    'repository_lack',	
+    'service',	
+    'service_lack',	
+    'interface',	
+    'interface_lack',	
+    'interfimps',	
+    'interfimps_lack',	
+    'cyclomatic_complexity_lack',	
+    'lines_of_code_lack',	
+    'lambda_count_lack',	
+    'nesting_depth_lack',	
+    'try_catch_count_lack',	
+]                
+
+# Чтение данных
+data = pd.read_excel('Modules_Error.xlsx')
+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. Генерация данных входных параметров на основе полного перебора значений с заданным шагом --------------------------------------------------------------
+# Входной файл из одной строки с нулями Modules_Error_Исходн_0.xlsx
+@njit
+def PolniPerebor_njit(data_init_np):
+    data_Max = 10000 #10000 
+    Parametr_shag = 40
+    PokazKachastva_Max = 1000
+    PokazKachastva_shag = 40
+    KolSluchZadaniiAnnot = 12
+    KolSluchZadaniiPokazKachastva = 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] - bean, data_[1] - bean_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] - component, data_[3] - component_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] - config, data_[5] - config_lack 
+              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] - controller, data_[7] - controller_lack 
+              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] - entity, data_[9] - entity_lack 
+              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] - repository, data_[11] - repository_lack 
+              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] - service, data_[13] - service_lack 
+              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] - interface, data_[15] - interface_lack 
+              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] - interfimps, data_[17] - interfimps_lack 
+              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];            
+            
+            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_[18] = aa                        # cyclomatic_complexity_lack
+                    bb = random.uniform(2, 5)
+                    aa = aa * bb
+                    if aa < lines_of_code_Min: aa = lines_of_code_Min
+                    data_[19] = aa                        # lines_of_code_lack
+                    data_[20] = random.uniform(0, j / 10) # lambda_count_lack
+                    aa = random.uniform(0, j / 2)
+                    if aa < nesting_depth_Min: aa = nesting_depth_Min
+                    data_[21] = aa                        # nesting_depth_lack
+                    data_[22] = 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 = [
+#     'bean', 'bean_lack', 'component', 'component_lack', 'config', 'config_lack',
+#     'controller', 'controller_lack', 'entity', 'entity_lack', 'repository', 'repository_lack',
+#     'service', 'service_lack', 'interface', 'interface_lack', 'interfimps', 'interfimps_lack',
+#     'cyclomatic_complexity_lack', 'lines_of_code_lack', 'lambda_count_lack',
+#     'nesting_depth_lack', '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('Modules_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, 'bean', 'bean_lack', target_min, 350, j)
+        target_summ += Gener_target_njit(data_np, columns_idx, 'component', 'component_lack', target_min, 150, j)
+        target_summ += Gener_target_njit(data_np, columns_idx, 'config', 'config_lack', target_min, 350, j)
+        target_summ += Gener_target_njit(data_np, columns_idx, 'controller', 'controller_lack', target_min, 250, j)
+        target_summ += Gener_target_njit(data_np, columns_idx, 'entity', 'entity_lack', target_min, 250, j)
+        target_summ += Gener_target_njit(data_np, columns_idx, 'repository', 'repository_lack', target_min, 500, j)
+        target_summ += Gener_target_njit(data_np, columns_idx, 'service', 'service_lack', target_min, 600, j)
+        target_summ += Gener_target_njit(data_np, columns_idx, 'interface', 'interface_lack', target_min, 250, j)
+        target_summ += Gener_target_njit(data_np, columns_idx, 'interfimps', 'interfimps_lack', target_min, 250, j)
+        
+        target_summ += Gener_target_njit(data_np, columns_idx, '', 'cyclomatic_complexity_lack', target_min, 650, j)
+        target_summ += Gener_target_njit(data_np, columns_idx, '', 'lines_of_code_lack', target_min, 500, j)
+        target_summ += Gener_target_njit(data_np, columns_idx, '', 'lambda_count_lack', target_min, 250, j)
+        target_summ += Gener_target_njit(data_np, columns_idx, '', 'nesting_depth_lack', target_min, 400, j)
+        target_summ += Gener_target_njit(data_np, columns_idx, '', 'try_catch_count_lack', target_min, 250, 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('Modules_Error_.xlsx', index=False)
+print('Файл сохранён.')
+
+
+# Чтение данных
+data = pd.read_excel('Modules_Error_.xlsx')
+data = data.astype(float)
+data.shape
+print('Данные загружены, data.shape = ', data.shape)
+'''
+
+
+
+
+
+'''
+# Чтение данных
+data = pd.read_excel('Modules_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('Modules_Error_.xlsx', 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} ''')
+
+
+--------------------------------------------------------------------------------------------------------------------
+
+Дан датафрейм data с колонками:
+'bean'
+'bean_lack'	
+'component'	
+'component_lack'	
+'config'	
+'config_lack'	
+'controller'	
+'controller_lack'	
+'entity'	
+'entity_lack'
+'repository'	
+'repository_lack'	
+'service'	
+'service_lack'	
+'interface'	
+'interface_lack'	
+'interfimps'	
+'interfimps_lack'	
+'cyclomatic_complexity_lack'	
+'lines_of_code_lack'	
+'lambda_count_lack'	
+'nesting_depth_lack'	
+'try_catch_count_lack'
+'target'
+
+и даны функции:
+@njit
+def Gener_target(Name_LOG, Name_LOG_lack, target_min, target_max, j):
+
+    if Name_LOG != '': # Если есть данные с LOG и с lack
+
+        targ = 0
+        i = data.at[j, Name_LOG]
+        k = data.at[j, Name_LOG_lack]
+        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: # Множитель при Name_LOG_lack = 0
+                targ = targ * (-5.0e-4 * i + 2.0) # targ * [от 1 - до 2]
+
+    else: # Если нет данных с LOG, есть только с lack
+    
+        targ = 0
+        i = data.at[j, Name_LOG_lack]
+        targ = data_Min + ((target_max - data_Min) * i) / data_Max  
+
+    return targ
+
+@njit
+def Opred_target():
+
+  target_min = 1
+  np.random.seed(0)
+  data_shape_0 = data.shape[0]
+
+  for j in range(data_shape_0):
+      if j % 5000 == 0: print(j)
+   
+      target_summ = 0
+      target_summ = target_summ + Gener_target('bean', 'bean_lack', target_min, 350, j)
+      target_summ = target_summ + Gener_target('component', 'component_lack', target_min, 150, j)
+      target_summ = target_summ + Gener_target('config', 'config_lack', target_min, 350, j)
+      target_summ = target_summ + Gener_target('controller', 'controller_lack', target_min, 250, j)
+      target_summ = target_summ + Gener_target('entity', 'entity_lack', target_min, 250, j)
+      target_summ = target_summ + Gener_target('repository', 'repository_lack', target_min, 500, j)
+      target_summ = target_summ + Gener_target('service', 'service_lack', target_min, 600, j)
+      target_summ = target_summ + Gener_target('interface', 'interface_lack', target_min, 250, j)
+      target_summ = target_summ + Gener_target('interfimps', 'interfimps_lack', target_min, 250, j)  
+
+      target_summ = target_summ + Gener_target('', 'cyclomatic_complexity_lack', target_min, 650, j)
+      target_summ = target_summ + Gener_target('', 'lines_of_code_lack', target_min, 500, j)
+      target_summ = target_summ + Gener_target('', 'lambda_count_lack', target_min, 250, j)
+      target_summ = target_summ + Gener_target('', 'nesting_depth_lack', target_min, 400, j)
+      target_summ = target_summ + Gener_target('', 'try_catch_count_lack', target_min, 250, j)
+
+      data.at[j, target] = target_summ
+
+  return data
+
+data = Opred_target(data) 
+
+Как преобразовать код, чтобы функции Gener_target и Opred_target работали с @njit ?
+
+
+
+
+
+