{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/gist/ArtemMareev/883771561dfb52aa209d736133872007/-range-0-600-_-y.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "edL5qcx_vf1S"
      },
      "source": [
        "Скрипт вычислений к статье \"Расширение диапазона измеряемых наклонов для малобюджетного цифрового видеоинклинометра\", авторы Мареев А. В., Янгалышев В. Р., Мамаев Д. С., Макеев А. В., Долин С. В."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OvuseAcAwaou"
      },
      "source": [
        "# Загрузка необходимых библиотек и данных"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mh1pbf65L9we"
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import glob\n",
        "import os\n",
        "import chardet\n",
        "import warnings\n",
        "import scipy\n",
        "from scipy.spatial import ConvexHull\n",
        "from scipy import stats\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import StandardScaler, PolynomialFeatures\n",
        "from sklearn.svm import SVR\n",
        "from sklearn.ensemble import RandomForestRegressor\n",
        "from sklearn.linear_model import LinearRegression\n",
        "from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score\n",
        "from sklearn.inspection import permutation_importance\n",
        "import xgboost as xgb\n",
        "import json\n",
        "\n",
        "\n",
        "\n",
        "warnings.filterwarnings('ignore')\n",
        "!pip install osfclient  # установка клиента для OSF\n",
        "!osf -p dbz8h clone"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ddejPL0VJ1TU"
      },
      "source": [
        "# Основные функции"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tALed1IncVwM"
      },
      "outputs": [],
      "source": [
        "# Функция загрузки файлов результата обработки записей с камеры видеоинклинометра\n",
        "# и вывода результатов транскрипции в формат Pandas dataframe\n",
        "\n",
        "def LoadCSV(path_csv):\n",
        "  all_files = glob.glob(os.path.join(path_csv, \"*.csv\"))\n",
        "\n",
        "  columns = [\n",
        "    'time', 'center_vim_bubble_X', 'center_vim_bubble_Y', 'vim_points_x', 'vim_points_y',\n",
        "    'vim_points_brig', 'method_vim', 'watch_indicator', 'nivel_x', 'nivel_y', 'nivel_t',\n",
        "    'temperature', 'laser_x', 'laser_y', 'laser_points_x', 'laser_points_y',\n",
        "    'laser_points_brig', 'method_laser', 'state_leds', 'Comment'\n",
        "    ]\n",
        "  dataframes = []\n",
        "  for f in all_files:\n",
        "    try:\n",
        "        df = pd.read_csv(\n",
        "            f,\n",
        "            sep=';',\n",
        "            names=columns,\n",
        "            encoding='utf-8',\n",
        "            engine='python',\n",
        "            on_bad_lines='skip'  # Пропускает проблемные строки\n",
        "        )\n",
        "        df['source_file'] = os.path.basename(f)\n",
        "        dataframes.append(df)\n",
        "        print(f\"✅ Обработан: {os.path.basename(f)}\")\n",
        "    except Exception as e:\n",
        "        print(f\"❌ Ошибка в файле {os.path.basename(f)}: {e}\")\n",
        "\n",
        "  if dataframes:\n",
        "      dataframe = pd.concat(dataframes, ignore_index=True)\n",
        "      dataframe = dataframe[dataframe['time'].str.contains(':', na=False)]\n",
        "\n",
        "  return dataframe\n",
        "\n",
        "# Функция вывода графика (временного ряда)\n",
        "def simple_graph(df,name):\n",
        "  plt.figure(figsize=(14, 6))\n",
        "  plt.plot(df.index, df['center_vim_bubble_X'], linewidth=0.8, marker='.', markersize=2)\n",
        "  plt.xlabel('Время')\n",
        "  plt.ylabel('center_vim_bubble_X'),plt.title(f'{name}: center_vim_bubble_X от времени (отфильтровано)')\n",
        "  plt.xticks(rotation=45, ha='right')\n",
        "  plt.grid(True, linestyle='--', alpha=0.6)\n",
        "  plt.tight_layout()\n",
        "  plt.show()\n",
        "\n",
        "# Функция оценки коэффициента линейного дрейфа нулевой точки (центра масс по оси x)\n",
        "# видеоинклинометра по температуре\n",
        "def temp_calib(df):\n",
        "  df['temperature'] = pd.to_numeric(df['temperature'], errors='coerce')\n",
        "  df['center_vim_bubble_X'] = pd.to_numeric(df['center_vim_bubble_X'], errors='coerce')\n",
        "\n",
        "# Вычисление коэффициентов линейной регрессии: center_x = a * t + b\n",
        "\n",
        "  valid_for_fit = df.dropna(subset=['temperature', 'center_vim_bubble_X'])\n",
        "  x_temp = valid_for_fit['temperature'].values.astype(np.float64)\n",
        "  y_center = valid_for_fit['center_vim_bubble_X'].values.astype(np.float64)\n",
        "  temp_coeffs=stats.linregress(x_temp,y_center )\n",
        "  a = temp_coeffs.slope\n",
        "  b = temp_coeffs.intercept\n",
        "\n",
        "  range=x_temp.max()-x_temp.min()\n",
        "\n",
        "  temp_diff = (x_temp*a+b-y_center)*0.6\n",
        "\n",
        "  iqr=scipy.stats.iqr(temp_diff)\n",
        "  median=np.median(temp_diff)\n",
        "\n",
        "  sw_test=scipy.stats.shapiro(temp_diff)\n",
        "  print('СКП коэфф. дрейфа нулевой точки по температуры = ', temp_diff.std())\n",
        "  print('Корреляция температуры и центроиды=', temp_coeffs.rvalue)\n",
        "  print('Шапиро_уилк тест =', sw_test)\n",
        "  print('Дрейф нулевой точки, угловые секунды на градус цельсия', temp_coeffs.slope*0.6)\n",
        "  print('Медиана для ряда разностей', median)\n",
        "  print('IQR/2', iqr/2)\n",
        "  print('Диапазон изменения температуры', range)\n",
        "  return a,b\n",
        "\n",
        "# Функция калибровки за температуру для каждой точки\n",
        "def calibrate_points_csv(val, delta):\n",
        "    if pd.isna(delta) or not isinstance(val, str) or not val.strip():\n",
        "        return np.nan\n",
        "    try:\n",
        "        points = [float(x.strip()) for x in val.split(',')]\n",
        "        return [p - float(delta) for p in points]\n",
        "    except Exception:\n",
        "        return np.nan\n",
        "\n",
        "#Функция преобразования данных во float\n",
        "def safe_float_conversion(val):\n",
        "\n",
        "    if pd.isna(val) or val is None:\n",
        "        return np.nan\n",
        "    try:\n",
        "        return float(val)\n",
        "    except (ValueError, TypeError):\n",
        "        return np.nan\n",
        "\n",
        "# Функция для преобразования списка координат точек в список float\n",
        "def parse_points(val):\n",
        "\n",
        "    if isinstance(val, str):\n",
        "        if not val.strip() or val.lower() in ['none', 'nan', 'null', '']:\n",
        "            return []\n",
        "        val = val.replace('[', '').replace(']', '').replace('(', '').replace(')', '')\n",
        "        parts = val.split(',')\n",
        "        nums = []\n",
        "        for part in parts:\n",
        "            p = part.strip()\n",
        "            if p and p.lower() not in ['none', 'nan', 'null', '']:\n",
        "                try:\n",
        "                    nums.append(float(p))\n",
        "                except ValueError:\n",
        "                    continue\n",
        "        return nums\n",
        "    elif isinstance(val, (list, tuple, np.ndarray)):\n",
        "        if len(val) == 0:\n",
        "            return []\n",
        "        try:\n",
        "            return [float(x) for x in val if x is not None and str(x).lower() not in ['none', 'nan', 'null', '']]\n",
        "        except (TypeError, ValueError):\n",
        "            return []\n",
        "    else:\n",
        "        return []\n",
        "\n",
        "\n",
        "# Функция вычисления интегральных признаков по яркости контура\n",
        "# и координатам контура\n",
        "def extract_features_selected(df):\n",
        "\n",
        "    features = []\n",
        "\n",
        "    for idx, row in df.iterrows():\n",
        "        feature_row = []\n",
        "        x_points = row.get('vim_points_x', [])\n",
        "        y_points = row.get('vim_points_y', [])\n",
        "        brig_points = row.get('vim_points_brig', [])\n",
        "\n",
        "        # === ПРИЗНАКИ ЯРКОСТИ ===\n",
        "        brig_mean = np.nan\n",
        "        brig_skew = np.nan\n",
        "        centroid_x_brig = np.nan\n",
        "        centroid_y_brig = np.nan\n",
        "\n",
        "        if len(brig_points) > 0:\n",
        "            brig_array = np.array(brig_points)\n",
        "\n",
        "            try:\n",
        "                # Средняя яркость\n",
        "                brig_mean = np.mean(brig_array)\n",
        "\n",
        "                # Моменты распределения\n",
        "                brig_skew = stats.skew(brig_array) if len(brig_array) > 2 else np.nan\n",
        "\n",
        "                # Центроид по яркости\n",
        "                if len(x_points) > 0 and len(y_points) > 0 and len(brig_points) > 0 and len(x_points) == len(y_points) == len(brig_points):\n",
        "                    total_brig = np.sum(brig_array)\n",
        "                    centroid_x_brig = np.sum(np.array(x_points) * brig_array) / total_brig if total_brig != 0 else np.nan\n",
        "                    centroid_y_brig = np.sum(np.array(y_points) * brig_array) / total_brig if total_brig != 0 else np.nan\n",
        "\n",
        "            except Exception as e:\n",
        "                pass\n",
        "\n",
        "        # === ГЕОМЕТРИЧЕСКИЕ ПРИЗНАКИ ===\n",
        "        centroid_x = np.nan\n",
        "        centroid_y = np.nan\n",
        "        form_factor = np.nan\n",
        "        aspect_ratio = np.nan\n",
        "        point_density = np.nan\n",
        "        circularity = np.nan\n",
        "        bounding_box_diagonal = np.nan\n",
        "        orientation_angle = np.nan\n",
        "        n_points = np.nan\n",
        "\n",
        "        if len(x_points) > 0 and len(y_points) > 0 and len(x_points) == len(y_points):\n",
        "            try:\n",
        "                x_array = np.array(x_points)\n",
        "                y_array = np.array(y_points)\n",
        "                points = np.column_stack((x_array, y_array))\n",
        "\n",
        "                # Размеры контрура\n",
        "                shape_width = np.max(x_array) - np.min(x_array)\n",
        "                shape_height = np.max(y_array) - np.min(y_array)\n",
        "                shape_area = shape_width * shape_height\n",
        "                aspect_ratio = shape_width / (shape_height + 1e-10)\n",
        "\n",
        "                # Центроиды\n",
        "                centroid_x = np.mean(x_array)\n",
        "                centroid_y = np.mean(y_array)\n",
        "\n",
        "                # Количество точек\n",
        "                n_points = len(x_points)\n",
        "\n",
        "                # Выпуклая оболочка\n",
        "                hull = ConvexHull(points)\n",
        "                hull_area = hull.volume\n",
        "                hull_perimeter = hull.area\n",
        "\n",
        "                # Периметр контура\n",
        "                contour_perimeter = np.sum(np.linalg.norm(\n",
        "                    np.roll(points, -1, axis=0) - points, axis=1\n",
        "                ))\n",
        "\n",
        "                # Форма и компактность\n",
        "                form_factor = (4 * np.pi * hull_area) / (hull_perimeter ** 2 + 1e-10)\n",
        "\n",
        "                # Плотность точек\n",
        "                point_density = n_points / (hull_area + 1e-10)\n",
        "\n",
        "                # Дополнительные геометрические признаки\n",
        "                circularity = (4 * np.pi * hull_area) / (contour_perimeter ** 2 + 1e-10)\n",
        "                bounding_box_diagonal = np.sqrt(shape_width**2 + shape_height**2)\n",
        "                orientation_angle = np.arctan2(np.std(y_array), np.std(x_array) + 1e-10)\n",
        "\n",
        "            except Exception as e:\n",
        "                pass\n",
        "\n",
        "        # Сбор выбранных признаков в определенном порядке\n",
        "        feature_row = [\n",
        "            brig_mean, centroid_x_brig, centroid_y_brig, centroid_x, centroid_y,\n",
        "            form_factor, aspect_ratio, point_density, circularity, bounding_box_diagonal,\n",
        "            orientation_angle, n_points, brig_skew\n",
        "        ]\n",
        "\n",
        "        features.append(feature_row)\n",
        "\n",
        "    # Список из 13 наиболее информативных признаков по МЛР-регресии\n",
        "    feature_columns = [\n",
        "        'brig_mean', 'centroid_x_brig', 'centroid_y_brig', 'centroid_x', 'centroid_y',\n",
        "        'form_factor', 'aspect_ratio', 'point_density', 'circularity', 'bounding_box_diagonal',\n",
        "        'orientation_angle', 'n_points', 'brig_skew'\n",
        "    ]\n",
        "    return pd.DataFrame(features, columns=feature_columns)\n",
        "def plot_np_ser(np_ser):\n",
        "  df_plot=pd.DataFrame(np_ser)\n",
        "  df_plot.plot()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tN8lyYXnJ9gp"
      },
      "source": [
        "# Загрузка файлов результатов измерений (калибровочный и тестовый файлы), файла отдельного сеанса для оценки дрефа начальной точки по температуре\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vD8h5H30WDom"
      },
      "outputs": [],
      "source": [
        "# Функция загрузка калибровочного файла и выбора фрагмента по заданным диапазонам\n",
        "\n",
        "def download_exp_data_end_transform(range_ex):\n",
        "  #range_ex : '0-200', '200-400', '400-600' только нужно сменить диапазон!!!!!\n",
        "\n",
        "  # Функция фильтрация по диапазонам (выбор по моментам наблюдений)\n",
        "\n",
        "  def TimeRange(range):\n",
        "    if range == '0-200':\n",
        "      return combined_df[((combined_df.index >= pd.Timestamp('1900-01-01 14:00:50.747951')) & (combined_df.index <= pd.Timestamp('1900-01-01 15:22:54.358478'))) | (combined_df.index >= pd.Timestamp('1900-01-01 16:11:45.080013'))]\n",
        "    elif range == '200-400':\n",
        "      return combined_df[((combined_df.index >= pd.Timestamp('1900-01-01 15:20:08.748489')) & (combined_df.index <= pd.Timestamp('1900-01-01 15:37:13.794125'))) | ((combined_df.index >= pd.Timestamp('1900-01-01 15:58:14.279887')) & (combined_df.index <= pd.Timestamp('1900-01-01 16:11:59.484933')))]\n",
        "    elif range == '400-600':\n",
        "      return combined_df[(combined_df.index >= pd.Timestamp('1900-01-01 15:36:05.554868')) & (combined_df.index <= pd.Timestamp('1900-01-01 15:59:05.554868'))]\n",
        "\n",
        "  folder_path_calibrate = '/content/dbz8h/osfstorage/Ranges 0-600/calibrate file'\n",
        "\n",
        "  # Создание dataframe\n",
        "  combined_df = LoadCSV(folder_path_calibrate)\n",
        "\n",
        "  # Фильтрация массива по наличию смещений по watch_indicator (индикатор часового типа)\n",
        "  combined_df = combined_df[(combined_df['watch_indicator'].notna()) & (combined_df['watch_indicator'] != '') & (combined_df['watch_indicator'] != 'None')]\n",
        "\n",
        "  # Преобразование типа моментов наблюдений\n",
        "  combined_df['time'] = pd.to_datetime(combined_df['time'], format='%H:%M:%S.%f', errors='coerce')\n",
        "  combined_df = combined_df.dropna(subset=['time']).sort_values('time').set_index('time')\n",
        "\n",
        "\n",
        "  # Фильтр по выбранному диапазону исследования\n",
        "\n",
        "  combined_df = TimeRange(range_ex)\n",
        "\n",
        "  combined_df['center_vim_bubble_X'] = pd.to_numeric(combined_df['center_vim_bubble_X'], errors='coerce')\n",
        "  if range_ex == '200-400' or range_ex == '400-600':\n",
        "    combined_df = combined_df[(combined_df['center_vim_bubble_X'] >= -325) & (combined_df['center_vim_bubble_X'] <= -10)]\n",
        "  elif range_ex == '0-200':\n",
        "    combined_df = combined_df[(combined_df['center_vim_bubble_X'] >= -325) & (combined_df['center_vim_bubble_X'] <= 30)].dropna(subset=['center_vim_bubble_X'])\n",
        "\n",
        "  # Загрузка тестового файла\n",
        "\n",
        "  folder_path_test = f'/content/dbz8h/osfstorage/Ranges 0-600/range {range_ex}'\n",
        "\n",
        "  # Создание dataframe\n",
        "  combined_df_test = LoadCSV(folder_path_test)\n",
        "\n",
        "  # Фильтрация массива по наличию смещений по watch_indicator (индикатор часового типа)\n",
        "  combined_df_test = combined_df_test[(combined_df_test['watch_indicator'].notna()) & (combined_df_test['watch_indicator'] != '') & (combined_df_test['watch_indicator'] != 'None')]\n",
        "\n",
        "  combined_df_test['center_vim_bubble_X'] = pd.to_numeric(combined_df_test['center_vim_bubble_X'], errors='coerce')\n",
        "\n",
        "  if range_ex == '200-400' or range_ex == '400-600':\n",
        "    combined_df_test = combined_df_test[(combined_df_test['center_vim_bubble_X'] >= -325) & (combined_df_test['center_vim_bubble_X'] <= -10)]\n",
        "  elif range_ex == '0-200':\n",
        "    combined_df_test = combined_df_test[(combined_df_test['center_vim_bubble_X'] >= -325) & (combined_df_test['center_vim_bubble_X'] <= 30)].dropna(subset=['center_vim_bubble_X'])\n",
        "\n",
        "  # Преобразование типа моментов наблюдений\n",
        "  combined_df_test['time'] = pd.to_datetime(combined_df_test['time'], format='%H:%M:%S.%f', errors='coerce')\n",
        "  combined_df_test = combined_df_test.dropna(subset=['time']).sort_values('time').set_index('time')\n",
        "  return combined_df_test, combined_df\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0gcA34wNsckr",
        "outputId": "f086f13d-ea88-40c4-f2ad-ec4a54338740"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "✅ Обработан: 2025_10_24 15_05_59.csv\n",
            "✅ Обработан: 2025_10_30 15_54_39.csv\n",
            "✅ Обработан: 2025_10_27 12_26_13.csv\n",
            "СКП коэфф. дрейфа нулевой точки по температуры =  1.3658672637107143\n",
            "Корреляция температуры и центроиды= 0.9487041447816599\n",
            "Шапиро_уилк тест = ShapiroResult(statistic=np.float64(0.530249329769086), pvalue=np.float64(4.902707938357175e-109))\n",
            "Дрейф нулевой точки, угловые секунды на градус цельсия 4.433630206462455\n",
            "Медиана для ряда разностей 0.007082766826073339\n",
            "IQR/2 0.6950792625105038\n",
            "Диапазон изменения температуры 3.125\n",
            "Коэффициенты калибровки: a = 7.389384, b = -187.352775\n",
            "Изменение температуры ампулы в ходе эксперимента, тестовый сеанс -0.5\n",
            "Изменение температуры эталона, тестовый сеанс -0.8999999999999986\n"
          ]
        }
      ],
      "source": [
        "# Выбор диапазона  исследования в угловых секундах (для анализа) : '0-200', '200-400', '400-600'\n",
        "range_ex='400-600'\n",
        "combined_df_test,combined_df = download_exp_data_end_transform(range_ex)\n",
        "\n",
        "#Оценка дрейфа начальной точки инклинометра по температуре\n",
        "\n",
        "# Загрузка файла сеанса для определения дрейфа начальной точки\n",
        "#инклинометра по температуре\n",
        "\n",
        "folder_path_calibrate_temp = '/content/dbz8h/osfstorage/Ranges 0-600/temperature calibration'\n",
        "combined_df_temp = LoadCSV(folder_path_calibrate_temp)\n",
        "\n",
        "#Применение функции калибровки для оценки параметров модели\n",
        "#дрейфа начальной точки\n",
        "a,b = temp_calib(combined_df_temp)\n",
        "print(f\"Коэффициенты калибровки: a = {a:.6f}, b = {b:.6f}\")\n",
        "\n",
        "\n",
        "# Расчет поправок за температурный дрейф начальной точки\n",
        "#для калибровочного файла, сохранения вектора поправок в виде отдельного\n",
        "# столбца DataFrame\n",
        "combined_df['temperature'] = pd.to_numeric(combined_df['temperature'], errors='coerce')\n",
        "\n",
        "delta_x = a * combined_df['temperature'] + b  # смещение, вызванное температурой\n",
        "\n",
        "# Расчет поправок за температурный дрейф начальной точки\n",
        "#для тестового файла, сохранения вектора поправок в виде отдельного\n",
        "# столбца DataFrame\n",
        "\n",
        "combined_df_test['temperature'] = pd.to_numeric(combined_df_test['temperature'], errors='coerce')\n",
        "\n",
        "delta_x_test = a * combined_df_test['temperature'] + b\n",
        "\n",
        "#Ввод поправки за температуру\n",
        "delta_temp_nivel = (combined_df['nivel_y'].apply(safe_float_conversion)) - (delta_x*0.0015)\n",
        "combined_df_test['nivel_y_cal'] = combined_df_test['nivel_y'].apply(safe_float_conversion) - (delta_x_test*0.0015)\n",
        "\n",
        "\n",
        "\n",
        "print('Изменение температуры ампулы в ходе эксперимента, тестовый сеанс', combined_df_test['temperature'].min()-combined_df_test['temperature'].max())\n",
        "print('Изменение температуры эталона, тестовый сеанс', float((combined_df_test['nivel_t'].values).min())-float((combined_df_test['nivel_t'].values).max()))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EHTuO7BuAxaR",
        "outputId": "12d21c6c-2266-4d99-871d-6b5bd4786ce8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "=== Преобразование данных ===\n",
            "Всего записей в combined_df: 399\n",
            "Доступные эталонные значения: 399\n",
            "Изменение температуры ампулы в ходе эксперимента, калибровочный сеанс -0.5625\n",
            "Изменение температуры эталона, калибровочный сеанс -0.8000000000000007\n"
          ]
        }
      ],
      "source": [
        "df_calibration = combined_df.copy()\n",
        "\n",
        "# Применяем парсинг данных к combined_df\n",
        "print(\"=== Преобразование данных ===\")\n",
        "\n",
        "df_calibration['vim_points_x'] = df_calibration['vim_points_x'].apply(parse_points)\n",
        "df_calibration['vim_points_y'] = df_calibration['vim_points_y'].apply(parse_points)\n",
        "df_calibration['vim_points_brig'] = df_calibration['vim_points_brig'].apply(parse_points)\n",
        "df_calibration['nivel_y_cal'] = delta_temp_nivel\n",
        "\n",
        "# Проверка наличия данных\n",
        "print(f\"Всего записей в combined_df: {len(df_calibration)}\")\n",
        "print(f\"Доступные эталонные значения: {df_calibration['nivel_y'].notna().sum()}\")\n",
        "\n",
        "print('Изменение температуры ампулы в ходе эксперимента, калибровочный сеанс', combined_df['temperature'].min()-combined_df['temperature'].max())\n",
        "print('Изменение температуры эталона, калибровочный сеанс', float((combined_df['nivel_t'].values).min())-float((combined_df['nivel_t'].values).max()))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rFjfGNkMaCqm"
      },
      "source": [
        "# Калибровка инклинометра методом множественной линейной регрессией"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IkSDXyd4CQEv",
        "outputId": "c26de400-d055-4c6d-bb57-9f979dc3345b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "=== ДОСТУПНЫЕ ПРИЗНАКИ ===\n",
            " 1. brig_mean\n",
            " 2. centroid_x_brig\n",
            " 3. centroid_y_brig\n",
            " 4. centroid_x\n",
            " 5. centroid_y\n",
            " 6. form_factor\n",
            " 7. aspect_ratio\n",
            " 8. point_density\n",
            " 9. circularity\n",
            "10. bounding_box_diagonal\n",
            "11. orientation_angle\n",
            "12. n_points\n",
            "13. brig_skew\n",
            "Используется признаков: 5\n",
            "Размерность данных: (399, 5)\n",
            "Обнаружено пар признаков с корреляцией > 0.8: 0\n",
            "✅ Мультиколлинеарность не обнаружена (все корреляции < 0.8)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 2000x800 with 4 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "=== РЕЗУЛЬТАТЫ КАЛИБРОВКИ ===\n",
            "Метрики качества модели:\n",
            "  - ME:  0.000000\n",
            "  - STD:  30.820222\n",
            "  - R²:   0.758363\n",
            "Shapiro-Wilk test statistic: 0.9974\n",
            "p-value: 0.7853953795453044\n",
            "p-value: X_clean_selected_final\n",
            "Коэффициенты калибровочной модели ВИМ:\n",
            "   1. centroid_x_brig          : -36.754266\n",
            "   2. centroid_y_brig          : +25.619576\n",
            "   3. form_factor              : -3.705154\n",
            "   4. bounding_box_diagonal    : +2.911063\n",
            "   5. orientation_angle        : +21.269957\n",
            "  Свободный член: 225.569166\n",
            "Используется признаков: 5\n"
          ]
        }
      ],
      "source": [
        "# Построение калибровочной модели методом МЛР\n",
        "\n",
        "# Коэффициенты преобразования для Leica Nivel и VIM для перехода к угловым секундам\n",
        "\n",
        "nivel_conversion = 0.0047\n",
        "vim_conversion = 0.0015 / 0.0047\n",
        "\n",
        "# Извлечение выбранных признаков для построения регрессии\n",
        "df_calibration['nivel_t'] = pd.to_numeric(df_calibration['nivel_t'], errors='coerce')\n",
        "X_df_selected = extract_features_selected(df_calibration)\n",
        "y = df_calibration['nivel_y_cal'].values-(df_calibration['nivel_t'].values-df_calibration['nivel_t'][0])*nivel_conversion\n",
        "\n",
        "# Удаление строк с пропущенными значениями\n",
        "valid_mask = ~(X_df_selected.isna().any(axis=1) | np.isnan(y))\n",
        "X_clean_selected = X_df_selected[valid_mask].values\n",
        "y_clean_selected = y[valid_mask]\n",
        "\n",
        "# Вывод всех названий всех признаков\n",
        "print(\"\\n=== ДОСТУПНЫЕ ПРИЗНАКИ ===\")\n",
        "feature_names = X_df_selected.columns.tolist()\n",
        "for i, feature in enumerate(feature_names):\n",
        "    print(f\"{i+1:2d}. {feature}\")\n",
        "\n",
        "# Назначаение наиболее информативных признаков для соответствующих диапазонов\n",
        "#признаки подобраны эмпирически\n",
        "\n",
        "if range_ex == '0-200':\n",
        "  selected_feature_indices = [1,3,4,6,7,12]\n",
        "elif range_ex == '200-400':\n",
        "  selected_feature_indices = [1,2,5,6,7,8,9,10,11,12,13]\n",
        "elif range_ex == '400-600':\n",
        "  selected_feature_indices = [2,3,6,10,11]\n",
        "\n",
        "# Формирование списка выбранных признаков\n",
        "selected_features = []\n",
        "for idx in selected_feature_indices:\n",
        "    if 1 <= idx <= len(feature_names):\n",
        "        selected_features.append(feature_names[idx-1])\n",
        "\n",
        "\n",
        "if len(X_clean_selected) > 0 and len(selected_features) > 0:\n",
        "\n",
        "    # Преобразование значений наклона Nivel в угловые секунды\n",
        "    y_clean_converted = y_clean_selected / nivel_conversion\n",
        "\n",
        "\n",
        "\n",
        "    # Выбор только указанныех признаков для соответствующего диапазона\n",
        "    feature_indices = [feature_names.index(feature) for feature in selected_features]\n",
        "    X_clean_selected_final = X_clean_selected[:, feature_indices]\n",
        "\n",
        "    print(f\"Используется признаков: {len(selected_features)}\")\n",
        "    print(f\"Размерность данных: {X_clean_selected_final.shape}\")\n",
        "\n",
        "    # Нормализация отобранные признаков\n",
        "    scaler_final = StandardScaler()\n",
        "    X_final_normalized = scaler_final.fit_transform(X_clean_selected_final)\n",
        "\n",
        "    # Определение МЛР-модели для выбранного диапазона наклонов\n",
        "    model_final = LinearRegression()\n",
        "    model_final.fit(X_final_normalized, y_clean_converted)\n",
        "\n",
        "    # Анализ коррелированности выбранных признаков для МЛР\n",
        "\n",
        "    X_selected_df = pd.DataFrame(X_clean_selected_final, columns=selected_features)\n",
        "\n",
        "    # Вычисление матрицы корреляций\n",
        "    correlation_matrix = X_selected_df.corr().abs()\n",
        "\n",
        "    # Определение пар признаков с корреляцией более 0,8\n",
        "    high_corr_pairs = []\n",
        "    corr_threshold = 0.8  # Порог для высокой корреляции\n",
        "\n",
        "    for i in range(len(correlation_matrix.columns)):\n",
        "        for j in range(i + 1, len(correlation_matrix.columns)):\n",
        "            corr_value = correlation_matrix.iloc[i, j]\n",
        "            if corr_value > corr_threshold:\n",
        "                high_corr_pairs.append({\n",
        "                    'feature1': correlation_matrix.columns[i],\n",
        "                    'feature2': correlation_matrix.columns[j],\n",
        "                    'correlation': corr_value\n",
        "                })\n",
        "\n",
        "    # Сортировка пар по убыванию коэффициента корреляции\n",
        "    high_corr_pairs.sort(key=lambda x: x['correlation'], reverse=True)\n",
        "\n",
        "    print(f\"Обнаружено пар признаков с корреляцией > {corr_threshold}: {len(high_corr_pairs)}\")\n",
        "\n",
        "    if high_corr_pairs:\n",
        "        print(\"Пары с высокой корреляцией:\")\n",
        "        print(\"=\" * 70)\n",
        "        for i, pair in enumerate(high_corr_pairs):\n",
        "            print(f\"{i+1:2d}. {pair['feature1']:25s} <-> {pair['feature2']:25s}: {pair['correlation']:.4f}\")\n",
        "    else:\n",
        "        print(\"✅ Мультиколлинеарность не обнаружена (все корреляции < 0.8)\")\n",
        "\n",
        "    # Оценка точности построения калибровочной модели\n",
        "    #видеоинклинометра на выбраном диапазоне\n",
        "\n",
        "    # Калибровка данных всего временного ряда\n",
        "    y_pred_converted = model_final.predict(X_final_normalized)\n",
        "\n",
        "    # Вычисление массива разности в угловых секундах\n",
        "    differences_converted = y_pred_converted - y_clean_converted\n",
        "\n",
        "    # Статистические метрики (Стандартное отклонение, Среднее и коэфф. Корреляции)\n",
        "    std_diff_conv = np.std(differences_converted)\n",
        "    me_diff_conv = np.mean(differences_converted)\n",
        "    r2 = r2_score(y_clean_converted, y_pred_converted)\n",
        "\n",
        "    # Вывод графиков\n",
        "\n",
        "    plt.figure(figsize=(20, 8))\n",
        "\n",
        "    # График 1: Основной график разностей между калиброванным временным рядом ВИМ\n",
        "    #и эталоном Leica Nivel 220\n",
        "    plt.subplot(1, 3, 1)\n",
        "\n",
        "    # Сортировка данных для вывода вспомогательных линий на график\n",
        "    sort_idx = np.argsort(y_clean_converted)\n",
        "    y_true_sorted = y_clean_converted[sort_idx]\n",
        "    differences_sorted = differences_converted[sort_idx]\n",
        "\n",
        "    # Основная линия разности\n",
        "    plt.plot(y_true_sorted, differences_sorted, 'b-', linewidth=2, alpha=0.8, label='Ошибка')\n",
        "\n",
        "    # Горизонтальные вспомогательные линии\n",
        "    plt.axhline(y=std_diff_conv, color='red', linestyle='--', linewidth=2,\n",
        "                label=f'+1 STD ({std_diff_conv:.4f})')\n",
        "    plt.axhline(y=-std_diff_conv, color='red', linestyle='--', linewidth=2,\n",
        "                label=f'-1 STD ({std_diff_conv:.4f})')\n",
        "    plt.axhline(y=me_diff_conv, color='orange', linestyle='-.', linewidth=2,\n",
        "                label=f'ME ({me_diff_conv:.4f})')\n",
        "\n",
        "    plt.xlabel('Моменты наблюдений')\n",
        "    plt.ylabel('Ошибка калибровки, секунда')\n",
        "    plt.title(f'Ошибка калибровки ({len(selected_features)} признаков)\\nРучной выбор признаков')\n",
        "    plt.legend(loc='upper right')\n",
        "    plt.grid(True, alpha=0.3)\n",
        "\n",
        "    # График 2: Важность признаков (коэффициенты модели)\n",
        "    plt.subplot(1, 3, 2)\n",
        "\n",
        "    final_feature_importance = np.abs(model_final.coef_)\n",
        "\n",
        "    bars = plt.barh(selected_features, final_feature_importance,\n",
        "                   color='skyblue', edgecolor='black', alpha=0.7)\n",
        "\n",
        "    for bar, value in zip(bars, final_feature_importance):\n",
        "        plt.text(bar.get_width() + 0.001, bar.get_y() + bar.get_height()/2,\n",
        "                 f'{value:.4f}', ha='left', va='center', fontsize=10)\n",
        "\n",
        "    plt.xlabel('Важность признака (абс. значение коэф.)')\n",
        "    plt.title(f'Важность выбранных признаков\\n({len(selected_features)} признаков)')\n",
        "    plt.grid(True, alpha=0.3, axis='x')\n",
        "\n",
        "    # График 3: Матрица корреляций\n",
        "    plt.subplot(1, 3, 3)\n",
        "\n",
        "    # Визуализация матрицы корреляций\n",
        "    im = plt.imshow(correlation_matrix, cmap='coolwarm', aspect='auto', vmin=0, vmax=1)\n",
        "    plt.colorbar(im, label='Корреляция')\n",
        "    plt.xticks(range(len(selected_features)), selected_features, rotation=45, ha='right')\n",
        "    plt.yticks(range(len(selected_features)), selected_features)\n",
        "    plt.title('Матрица корреляций выбранных признаков')\n",
        "\n",
        "    # Добавление значений корреляции на heatmap\n",
        "    for i in range(len(selected_features)):\n",
        "        for j in range(len(selected_features)):\n",
        "            plt.text(j, i, f'{correlation_matrix.iloc[i, j]:.2f}',\n",
        "                    ha='center', va='center', fontsize=8)\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "    #Вычисления значений теста Шапиро-Уилка\n",
        "    statistic, p_value = stats.shapiro(differences_converted)\n",
        "\n",
        "    print(f\"\\n=== РЕЗУЛЬТАТЫ КАЛИБРОВКИ ===\")\n",
        "    print(f\"Метрики качества модели:\")\n",
        "    print(f\"  - ME:  {me_diff_conv:.6f}\")\n",
        "    print(f\"  - STD:  {std_diff_conv:.6f}\")\n",
        "    print(f\"  - R²:   {r2:.6f}\")\n",
        "    print(f\"Shapiro-Wilk test statistic: {statistic:.4f}\")\n",
        "    print(f\"p-value: {p_value}\")\n",
        "    print(f\"p-value: X_clean_selected_final\")\n",
        "\n",
        "\n",
        "    print(f\"Коэффициенты калибровочной модели ВИМ:\")\n",
        "    for i, (name, coef) in enumerate(zip(selected_features, model_final.coef_)):\n",
        "        print(f\"  {i+1:2d}. {name:25s}: {coef:+.6f}\")\n",
        "    print(f\"  Свободный член: {model_final.intercept_:.6f}\")\n",
        "\n",
        "# Запись калибровочных параметров ВИМ в файл\n",
        "\n",
        "    calibration_params = {\n",
        "        'model_coefficients': model_final.coef_.tolist(),\n",
        "        'intercept': float(model_final.intercept_),\n",
        "        'feature_names': selected_features,\n",
        "        'feature_importance': final_feature_importance.tolist(),\n",
        "        'scaler_params': {\n",
        "            'mean': scaler_final.mean_.tolist(),\n",
        "            'scale': scaler_final.scale_.tolist()\n",
        "        },\n",
        "        'conversion_factors': {\n",
        "            'nivel_conversion': nivel_conversion,\n",
        "            'vim_conversion': vim_conversion\n",
        "        },\n",
        "        'calibration_date': pd.Timestamp.now().strftime('%Y-%m-%d %H:%M:%S'),\n",
        "        'samples_used': len(X_clean_selected_final),\n",
        "        'metrics': {\n",
        "            'std_difference': float(std_diff_conv),\n",
        "            'me': float(me_diff_conv),\n",
        "            'r2_score': float(r2)\n",
        "        },\n",
        "        'multicollinearity_analysis': {\n",
        "            'high_correlation_pairs': high_corr_pairs,\n",
        "            'correlation_threshold': corr_threshold\n",
        "        }\n",
        "    }\n",
        "    print(f\"Используется признаков: {len(selected_features)}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IHU34EiDErQY",
        "outputId": "0b71e3d0-e5b0-4518-9a78-a7d91ce61b3b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Файл записан: calibration_results/vim_calibration_params.json\n"
          ]
        }
      ],
      "source": [
        "# Список всех признаков\n",
        "feature_columns = [\n",
        "    'brig_mean', 'centroid_x_brig', 'centroid_y_brig', 'centroid_x', 'centroid_y',\n",
        "        'form_factor', 'aspect_ratio', 'point_density', 'circularity', 'bounding_box_diagonal',\n",
        "        'orientation_angle', 'n_points', 'brig_skew'\n",
        "]\n",
        "# Сбор параметров модели калибровки ВИМ\n",
        "calibration_params = {\n",
        "    'calibration_type': 'multiple_linear_regression',\n",
        "    'model_coefficients': model_final.coef_.tolist(),\n",
        "    'intercept': float(model_final.intercept_),\n",
        "    'feature_names': selected_features,\n",
        "\n",
        "  # Параемтры для нормализации признаков\n",
        "    'scaler_params': {\n",
        "        'mean': scaler_final.mean_.tolist(),      # Средние значения обучающих данных\n",
        "        'std': scaler_final.scale_.tolist(),      # Стандартные отклонения обучающих данных\n",
        "        'n_features': len(scaler_final.mean_)     # Количество признаков\n",
        "    },\n",
        "\n",
        "    'conversion_factors': {\n",
        "        'nivel_conversion': nivel_conversion,\n",
        "        'vim_conversion': vim_conversion\n",
        "    },\n",
        "    'metrics': {\n",
        "        'std_difference': float(np.std(differences_converted)),\n",
        "        'me': float(np.mean((differences_converted))),\n",
        "        'r2_score': float(r2),\n",
        "        'mean_difference': float(np.mean(differences_converted)),\n",
        "        'max_difference': float(np.max(np.abs(differences_converted)))\n",
        "    },\n",
        "    'calibration_date': pd.Timestamp.now().strftime('%Y-%m-%d %H:%M:%S'),\n",
        "    'samples_used': len(X_clean_selected_final),\n",
        "    'data_info': {\n",
        "        'nivel_min': float(y_clean_converted.min()),\n",
        "        'nivel_max': float(y_clean_converted.max()),\n",
        "        'nivel_mean': float(y_clean_converted.mean()),\n",
        "        'nivel_std': float(y_clean_converted.std())\n",
        "    },\n",
        "    'feature_statistics': {\n",
        "        'total_features_extracted': len(feature_columns),\n",
        "        'selected_features_count': len(selected_features),\n",
        "        'selection_method': 'standardized_coefficients'\n",
        "    }\n",
        "}\n",
        "# Создание директории\n",
        "os.makedirs('calibration_results', exist_ok=True)\n",
        "\n",
        "# Запись в JSON-файл\n",
        "with open('calibration_results/vim_calibration_params.json', 'w', encoding='utf-8') as f:\n",
        "    json.dump(calibration_params, f, indent=2, ensure_ascii=False)\n",
        "print(\"Файл записан: calibration_results/vim_calibration_params.json\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aAXorGOSpK9f"
      },
      "source": [
        "# Оценка точности МЛР модели на тестовом сеансе"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 663
        },
        "id": "To3DgnUvFbjD",
        "outputId": "4c115da9-2722-427b-99ba-6d52776c888d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "=== РЕЗУЛЬТАТЫ ===\n",
            "  Средняя ошибка: 0.195660\n",
            "  СКО:            31.808786\n",
            "\n",
            "  IQR/2: 23.445992\n",
            "  Медиана:            0.071719\n",
            "\n",
            "Shapiro-Wilk test statistic: 0.9919\n",
            "p-value: 0.0309739565936316\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1800x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "#  Подготовка массивов данных для оценки точности на тестовом сеансе\n",
        "combined_df_test['vim_points_x'] = combined_df_test['vim_points_x'].apply(parse_points)\n",
        "combined_df_test['vim_points_y'] = combined_df_test['vim_points_y'].apply(parse_points)\n",
        "combined_df_test['vim_points_brig'] = combined_df_test['vim_points_brig'].apply(parse_points)\n",
        "combined_df_test['nivel_t'] = pd.to_numeric(combined_df_test['nivel_t'], errors='coerce')\n",
        "nivel_true = (combined_df_test['nivel_y_cal'] - (combined_df_test['nivel_t'].values-combined_df_test['nivel_t'][0])*nivel_conversion ).values / 0.0047\n",
        "\n",
        "\n",
        "# Извлечение признаков ---\n",
        "X_raw = extract_features_selected(combined_df_test)\n",
        "valid_mask = (~X_raw.isna().any(axis=1).values) & (~np.isnan(nivel_true))\n",
        "\n",
        "# Загрузка файла калибровочной модели МЛР\n",
        "with open('calibration_results/vim_calibration_params.json', 'r') as f:\n",
        "    calib = json.load(f)\n",
        "feature_names = calib['feature_names']\n",
        "coef = np.array(calib['model_coefficients'])\n",
        "intercept = calib['intercept']\n",
        "nivel_conv = calib['conversion_factors']['nivel_conversion']\n",
        "\n",
        "# Параметры нормализации из обучающей выборки\n",
        "scaler_mean = np.array(calib['scaler_params']['mean'])\n",
        "scaler_std = np.array(calib['scaler_params']['std'])\n",
        "\n",
        "# Фильтрация моментов наблюдений (валидные эпохи)\n",
        "X_clean = X_raw.loc[valid_mask, feature_names].values\n",
        "nivel_clean = nivel_true[valid_mask]\n",
        "\n",
        "# Нормализация признаков с использованием сохранённых параметров калибровочной модели\n",
        "X_normalized = (X_clean - scaler_mean) / scaler_std\n",
        "\n",
        "# Прогноз калибровочной модели\n",
        "vim_converted = intercept + X_normalized.dot(coef)\n",
        "\n",
        "# Вычисление средних значений признаков в текущих данных\n",
        "current_feature_means = np.mean(X_clean, axis=0)\n",
        "\n",
        "# Вычисление нормированного дрейфа признаков относительно обучающей выборки\n",
        "feature_drift_norm = (current_feature_means - scaler_mean) / scaler_std\n",
        "\n",
        "# Прогнозный систематический сдвиг в выходе модели\n",
        "predicted_output_shift = np.dot(coef, feature_drift_norm)\n",
        "\n",
        "# Коррекция прогноза калибровочной модели\n",
        "vim_calibrated = vim_converted - predicted_output_shift\n",
        "\n",
        "# Вычисление временного ряда разностей с эталоном\n",
        "diff = vim_calibrated- nivel_clean\n",
        "\n",
        "# Расчет и вывод основных метрик исследования\n",
        "def compute_metrics(diff):\n",
        "    mean_err = np.mean(diff)\n",
        "    std_err = np.std(diff)\n",
        "    statistic, p_value = stats.shapiro(diff)\n",
        "    iqr=scipy.stats.iqr(diff)\n",
        "    median=np.median(diff)\n",
        "    print(f\"  Средняя ошибка: {mean_err:.6f}\")\n",
        "    print(f\"  СКО:            {std_err:.6f}\\n\")\n",
        "    print(f\"  IQR/2: {iqr/2:.6f}\")\n",
        "    print(f\"  Медиана:            {median:.6f}\\n\")\n",
        "    print(f\"Shapiro-Wilk test statistic: {statistic:.4f}\")\n",
        "    print(f\"p-value: {p_value}\")\n",
        "\n",
        "print(\"=== РЕЗУЛЬТАТЫ ===\")\n",
        "compute_metrics(diff)\n",
        "diff600_MLR=diff\n",
        "# Построение графика разностей\n",
        "plt.figure(figsize=(18, 5))\n",
        "plt.subplot(1, 3, 3)\n",
        "plt.plot(diff, color='purple', linewidth=1)\n",
        "plt.axhline(0, color='black', linestyle='--', linewidth=0.8)\n",
        "plt.title('Временной ряд разностей с эталоном, секунды', fontsize=12)\n",
        "plt.xlabel('Моменты наблюдений')\n",
        "plt.grid(True, alpha=0.3)\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "diff"
      ],
      "metadata": {
        "id": "RU3Ny45Ispwu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Построение блочных диаграмм для массива разностей с эталонными значениями\n",
        "data=[diff200_MLR, diff_200_GBDT, diff400_MLR, diff_400_GBDT, diff600_MLR, diff_600_GBDT]\n",
        "plt.boxplot(data, labels=['\\u00B1 200 MLR', '\\u00B1 200 GBDT', '\\u00B1 400 MLR', '\\u00B1 400 GBDT', '\\u00B1 600 MLR', '\\u00B1 600 GBDT',])\n",
        "plt.ylabel('Ошибка, угловая секунда')\n",
        "plt.grid(True, linestyle='--', alpha=0.5)\n",
        "plt.savefig('boxplot.png', dpi=300)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 430
        },
        "id": "KmbfFUo0SFxI",
        "outputId": "ced45328-b705-41d4-b941-c7f36cfe637a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGdCAYAAAD60sxaAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAe29JREFUeJzt3Xd8FNX6P/DPzIYN6YVUSAibkBCaAqErgoiAwhcQuKgXpF4UDUpHbGBBIl2xUK4iYkURkQuCIhbipSeiUkJCSAiEbCDEVCBlZ35/5Ldzs8lu2N2czezMPu/Xy5fk7GTynGfOJs/OnDPDiaIoghBCCCHEhfByB0AIIYQQ0tSoACKEEEKIy6ECiBBCCCEuhwogQgghhLgcKoAIIYQQ4nKoACKEEEKIy6ECiBBCCCEuhwogQgghhLgcN7kDcDaCIODKlSvw8fEBx3Fyh0MIIYQQK4iiiNLSUrRs2RI8f/vzO1QA1XHlyhVERkbKHQYhhBBC7HDp0iVERETcdjsqgOrw8fEBUJNAX19fmaMxz2AwIDMzEzExMdBoNHKHo2iUSzYoj+xQLtmhXLKhlDyWlJQgMjJS+jt+O1QA1WG87OXr6+vUBZC3tzd8fX2dejAqAeWSDcojO5RLdiiXbCgtj9ZOX6FJ0IQQQghxOVQAKRDP8wgLC7NqkhdpGOWSDcojO5RLdiiXbKg1j3QJTIE4joO/v7/cYagC5ZINyiM7lEt2KJdsqDWP6irnXIQgCLhw4QIEQZA7FMWjXLJBeWSHcskO5ZINteaRCiAFEkURlZWVEEVR7lAUj3LJBuWRHcolO5RLNtSaRyqACCGEEOJyqAAihBBCiMuhAkiBeJ5HRESE6mbky4FyyQblkR3KJTuUSzbUmkdaBaZAHMfB29tb7jBUgXLJBuWRHcolO5RLNtSaR8WUcwaDAS+99BJ0Oh08PDwQExOD1157zWRSliiKWLx4McLDw+Hh4YFBgwYhIyNDxqgdw2AwID09HQaDQe5QFI9yyQblkR3KJTuUSzbUmkfFFEDLly/H+vXr8c477+Ds2bNYvnw5VqxYgbffflvaZsWKFVi3bh02bNiAo0ePwsvLC0OGDMGtW7dkjNwx1LYcUU6USzYoj+xQLtmhXLKhxjwq5hLYoUOHMHLkSAwbNgwA0KZNG3z++ec4duwYgJqzP2+++SZefPFFjBw5EgCwdetWhIaGYufOnXjkkUdki50QQgghzkUxBVDfvn2xadMmpKenIy4uDn/88Qd+++03rFmzBgCQlZUFvV6PQYMGSd/j5+eHXr164fDhwxYLoIqKClRUVEhfl5SUAKg55Wc83cdxHHiehyAIJpfcLLXzPA+O4yy21z2NaJxYVrfCttQO1BR8tfdjjEUURZPtbY1drj5pNBqLsTuyT+ZyqfQ+yXGcAMtjUql9kus4GWOsOyaV3CeWx6msrAxpaWlW9am0tBRHjx5Fr1694Onpeds+xcXFwcPDo8n75OzHyRiLNWNS7j7ZQjEF0KJFi1BSUoL4+HhoNBoYDAa8/vrrGD9+PABAr9cDAEJDQ02+LzQ0VHrNnKSkJLzyyiv12jMzM6VJX35+fggPD0d+fj6Ki4ulbYKCghAUFITc3FyUl5dL7WFhYfD390d2djYqKyul9oiICHh7eyMzM9PkQOl0Ori5udWbrxQbG4vq6mpkZWVJbTzPIzY2FqGhocjMzJT++Gi1WkRHR6O4uNikv15eXoiMjERhYSEKCgqkdmfrU1xcHMrLy3H58mWpvSn65OfnB41GY5JLpfdJjuOk0+nQokULkzwqvU9yHScvLy8AMMml0vvE8jj98MMPGDt2LBxhz549iI6ObvI+Oftx0mg0EATBZEw6Y58uXrwIW3CiQm7t+MUXX2DBggVYuXIlOnbsiJMnT2L27NlYs2YNJk2ahEOHDuGuu+7ClStXEB4eLn3fuHHjwHEctm3bZna/5s4AGQ+Ir68vAOf7JMTzvMnZqdqxONOnBlv6JOcZoOrqanAcJ+VS6X2S4zjV3nfdManUPsl5BqiqqkraRg19kusM0OnTpzFx4kR89NFHaN++PZ0BsrNPoiiiurraqjEpZ5+KiooQEBCA4uJi6e93QxRzBmjBggVYtGiRdCmrc+fOuHjxIpKSkjBp0iSEhYUBAPLz800KoPz8fHTp0sXift3d3eHu7l6vXaPRQKPRmLQZD3hdtrbX3a+t7QaDAefPn0dsbGy91ziOM7sfVrE7qk+A5dgd2SeDwYDMzEyzuVRqnxpqd1SfGhqTSu1TQ+2O7JPBYMCFCxcaPSadqU+WYrS1neM4+Pj4oEePHma/py7jH/P27dtb/T3muMrYsxSjIAg2jUln65MlilkFduPGjXqdM56WA2pO04WFheHAgQPS6yUlJTh69Cj69OnTpLESQgghxLkp5gzQ//3f/+H1119H69at0bFjR/z+++9Ys2YNpk6dCqCmspw9ezaWLl2K2NhY6HQ6vPTSS2jZsiVGjRolb/CEEEIIcSqKKYDefvttvPTSS3jqqadw9epVtGzZEk888QQWL14sbbNw4UKUl5fj8ccfR1FREe6++27s27cPzZs3lzFyQgghhDgbxUyCbiolJSXw8/OzehKVHIwTyWpPSCP2oVyyQXlkh3LJTkpKCrp3744TJ04gISFB7nAUSylj0ta/34qZA0RMVVdXyx2CalAu2aA8skO5JM5GjWOSCiAFEgQBWVlZNt/0idRHuWSD8sgO5ZIdYw4pl42j1jFJBRAhhBBCXA4VQIQQQghxOVQAKZStN3willEu2aA8skO5JM5GjWNSMcvgyf9oNBrExcXJHYYqUC7ZoDyyQ7lkx3jXYUt3ZibWUeuYVF9J5wKMz8OhOxg0HuWSDcojO5RLdow5pFw2jlrHJBVACiQIAi5fvqy6GflyoFyyQXlkh3LJDq0CY0OtY5IKIEIIIYS4HCqACCGEEOJyqABSII7joNVqnfqW5EpBuWSD8sgO5ZIdYw4pl42j1jFJq8AUiOd5REdHyx2GKlAu2aA8skO5ZMe4dFuNS7ibklrHJI0KBRJFEUVFRaqbkS8HyiUblEd2KJfs0CowNtQ6JqkAUiBBEKDX61U3I18OlEs2KI/sUC7ZoVVgbKh1TFIBRAghhBCXQwUQIYQQQlwOFUAKxHEcvLy8VDcjXw6USzYoj+xQLtmhVWBsqHVM0iowBeJ5HpGRkXKHoQqUSzYoj+xQLtmhVWBsqHVM0qhQIEEQUFBQoLoJaXKgXLJBeWSHcskOTYJmQ61jkgogBRJFEQUFBapbkigHyiUblEd2KJfs0DJ4NtQ6JqkAIoQQQojLoQKIEEIIIS6HCiAF4jgOfn5+qpuRLwfKJRuUR3Yol+zQKjA21DomaRWYAvE8j/DwcLnDUAXKJRuUR3Yol+zQKjA21DomaVQokCAIyMvLU92MfDlQLtmgPLJDuWSHVoGxodYxSQWQAomiiOLiYtXNyJcD5ZINyiM7lEt2aBUYG2odk1QAEUIIIcTlUAFECCGEEJdDBZACcRyHoKAg1c3IlwPlkg3KIzuUS3ZoFRgbah2TtApMgXieR1BQkNxhqALlkg3KIzuUS3ZoFRgbah2TNCoUSBAEXLp0SXUz8uVAuWSD8sgO5ZIdWgXGhlrHJBVACiSKIsrLy1U3I18OlEs2KI/sUC7ZoVVgbKh1TCqqAMrNzcWECRPQokULeHh4oHPnzjhx4oT0uiiKWLx4McLDw+Hh4YFBgwYhIyNDxogJIYQQ4owUUwD9/fffuOuuu9CsWTPs3bsXZ86cwerVqxEQECBts2LFCqxbtw4bNmzA0aNH4eXlhSFDhuDWrVsyRk4IIYQQZ6OYSdDLly9HZGQkPvzwQ6lNp9NJ/xZFEW+++SZefPFFjBw5EgCwdetWhIaGYufOnXjkkUeaPGZH4XkeYWFhNLGPAcolG5RHdiiX7NAkaDbUOiYVUwDt2rULQ4YMwT/+8Q/8+uuvaNWqFZ566ilMnz4dAJCVlQW9Xo9BgwZJ3+Pn54devXrh8OHDFgugiooKVFRUSF+XlJQAAAwGAwwGA4CaJYA8z0MQBJNroJbaeZ4Hx3EW2437rd0O1J+oZ6ldo9HAz8/PpN0YiyiKZtutjV3OPlmK3dF98vX1Ndm/Gvokx3GyNCaV3Ce5jpOPj0+9Man0PslxnIxxCIIAg8Ggij7JdZysHZNy98kWiimALly4gPXr12Pu3Ll4/vnncfz4cTzzzDPQarWYNGkS9Ho9ACA0NNTk+0JDQ6XXzElKSsIrr7xSrz0zMxPe3t4Aagqp8PBw5Ofno7i4WNomKCgIQUFByM3NRXl5udQeFhYGf39/ZGdno7KyUmqPiIiAt7c3MjMzTQ6UTqeDm5tbvflKsbGxqK6uRlZWltTG8zzatm2Lc+fOAfjf/S20Wi2io6NRXFxs0l8vLy9ERkaisLAQBQUFUruz9SkuLg7l5eW4fPmy1N4UffL19UVKSgq8vb2lXCq9T3IcpzZt2uDs2bPSLyI19Emu4+Tp6Ynjx4+bPH1b6X2S6zgVFRUBAHJycuDj46OKPslxnHiex4kTJ+Dv7y+NSWfs08WLF2ELTlTItG6tVovu3bvj0KFDUtszzzyD48eP4/Dhwzh06BDuuusuXLlyxeSptePGjQPHcdi2bZvZ/Zo7A2Q8IL6+vgCc75MQAKSnpyMmJgYajcYkFmf71ODsn4QEQaiXS6X3SY7jJIqixTGp1D7JdZwEQcC5c+fQtm1bkzGp5D7JdZyOHTuGXr164ciRI+jevbsq+iTHcTIYDEhPT7dqTMrZp6KiIgQEBKC4uFj6+90QxZwBCg8PR4cOHUza2rdvj6+//hpATQUIAPn5+SYFUH5+Prp06WJxv+7u7nB3d6/XrtFopANtZDzgddnaXne/trYbT+Wai9HY3tgYm7pPgOXYHd0nS7lUcp+a+jg1NCaV2qeG2h3dJ57nGz0mna1Pchwn49kKYz5vF6MS+iTHcTIWHtaOSWfrkyWKmdF01113SZd9jNLT0xEVFQWg5jRdWFgYDhw4IL1eUlKCo0ePok+fPk0aKyGEEEKcm2LOAM2ZMwd9+/bFsmXLMG7cOBw7dgybNm3Cpk2bANRUlrNnz8bSpUsRGxsLnU6Hl156CS1btsSoUaPkDZ4xnucRERFhc7VL6qNcskF5ZIdyyY4xh5TLxlHrmFRMAdSjRw988803eO655/Dqq69Cp9PhzTffxPjx46VtFi5ciPLycjz++OMoKirC3XffjX379qF58+YyRs4ex3HSBG3SOJRLNiiP7FAu2TFeAjP+n9hHrWNSMZOgm0pJSQn8/PysnkQlB4PBgMzMTJMJp8Q+lEs2KI/sUC7ZOX78OHr27Iljx46hR48ecoejWEoZk7b+/VbX+SwXYuv9DohllEs2KI/sUC6Js1HjmKQCiBBCCCEuhwogQgghhLgcKoAUiOd56e6cpHEol2xQHtmhXLJDq8DYUOuYVFdvXIibm2IW8Dk9yiUblEd2KJfE2ahxTFIBpECCICAjI0OVk9KaGuWSDcojO5RLdow5pFw2jlrHJBVAhBBCCHE5VAARQgghxOVQAUQIIYQQl0MFkALxPI/Y2FjVzciXA+WSDcojO5RLdmgVGBtqHZPq6o0Lqa6uljsE1aBcskF5ZIdySZyNGsckFUAKJAgCsrKyVDcjXw6USzYoj+xQLtmhVWBsqHVMUgFECCGEEJdDBRAhhBBCXA4VQAqltslocqJcskF5ZIdySZyNGsek+u5t7QI0Gg3i4uLkDkMVKJdsUB7ZoVyyo9FoTP5P7KPWMam+ks4FiKKIsrIyiKIodyiKR7lkg/LIDuWSHWMOKZeNo9YxSQWQAgmCgMuXL6tuRr4cKJdsUB7ZoVyyQ6vA2FDrmKQCiBBCCCEuhwogQgghhLgcKoAUiOM4aLVacBwndyiKR7lkg/LIDuWSHWMOKZeNo9YxSavAFIjneURHR8sdhipQLtmgPLJDuWSHngXGhlrHJI0KBRJFEUVFRaqbkS8HyiUblEd2KJfs0CowNtQ6JqkAUiBBEKDX61U3I18OlEs2KI/sUC7ZoVVgbKh1TFIBRAghhBCXQwUQIYQQQlyOXZOgt2/fji+//BI5OTmorKw0eS01NZVJYMQyjuPg5eWluhn5cqBcskF5ZIdyyQ6tAmNDrWPS5jNA69atw5QpUxAaGorff/8dPXv2RIsWLXDhwgU88MADjoiR1MHzPCIjI2llAwOUSzYoj+xQLtmhVWBsqHVM2tyb9957D5s2bcLbb78NrVaLhQsXYv/+/XjmmWdQXFzsiBhJHYIgoKCgQHUT0uRAuWSD8sgO5ZIdmgTNhlrHpM0FUE5ODvr27QsA8PDwQGlpKQDgsccew+eff842OmKWKIooKChQ3ZJEOVAu2aA8skO5ZIeWwbOh1jFpcwEUFhaGwsJCAEDr1q1x5MgRAEBWVpbqkkMIIYQQdbK5ABo4cCB27doFAJgyZQrmzJmD+++/Hw8//DAeeugh5gESQgghhLBmcwG0adMmvPDCCwCAxMREbN68Ge3bt8err76K9evXMw/QkjfeeAMcx2H27NlS261bt5CYmIgWLVrA29sbY8aMQX5+fpPF1FQ4joOfn5/qZuTLgXLJBuWRHcolO7QKjA21jkmbl8HzPG8yE/yRRx7BI488wjSo2zl+/Dg2btyIO+64w6R9zpw52LNnD7766iv4+flh5syZGD16NP773/82aXyOxvM8wsPD5Q5DFSiXbFAe2aFcskOrwNhQ65hkNiqKioowcOBADBw4EGPHjmW123rKysowfvx4/Pvf/0ZAQIDUXlxcjA8++ABr1qzBwIEDkZCQgA8//BCHDh2S5imphSAIyMvLU92MfDlQLtmgPLJDuWSHVoGxodYxafMZoG7dupltr66uxunTp5GamopmzZo1OjBLEhMTMWzYMAwaNAhLly6V2lNSUlBVVYVBgwZJbfHx8WjdujUOHz6M3r17OyympiaKIoqLixESEiJ3KIpHuWSD8sgO5ZIdWgXGhlrHpM0F0MmTJzFv3jx4e3ubtJeWluL06dO48847mQVX1xdffIHU1FQcP3683mt6vR5arRb+/v4m7aGhodDr9Rb3WVFRgYqKCunrkpISAIDBYIDBYABQc/2T53kIgmDyRrLUzvM8OI6z2G7cb+12oP6nFEvtQM2ArL0fYyyiKJpsb2vscvVJo9FYjN2RfTKXS6X3SY7jBFgek0rtk1zHyRhj3TGp5D7JdZyMcRjzqYY+yXGcjLFYMybl7pMt7HoUxoIFC+pVgnq9HmvXrrVnd1a5dOkSZs2ahf3796N58+bM9puUlIRXXnmlXntmZqZU5Pn5+SE8PBz5+fkmN3sMCgpCUFAQcnNzUV5eLrWHhYXB398f2dnZJo8KiYiIgLe3NzIzM00OlE6ng5ubGzIyMkxiiI2NRXV1NbKysqQ2nucRExODqqoqnD9/XhqEWq0W0dHRKC4uNin4vLy8EBkZicLCQhQUFEjtztanuLg4lJeX4/Lly1J7U/TJx8cHRUVFJrlUep/kOE5RUVGoqKgwyaPS+yTXcfLw8MDff/9tkkul90mu42SM+9KlS/Dz81NFn+Q4ThzHobCw0GRMOmOfLl68CFtwoo3nBjUaDfR6PYKDg03a8/Pz0bJly3rVIys7d+7EQw89BI1GI7XVrui///57DBo0CH///bfJWaCoqCjMnj0bc+bMMbtfc2eAjAfE19cXgPN9EuI4DtevX4e/v7+0jTN+arClT3J9ajDe4CsgIMBkwqSS+yTXGSBLY1KpfZLrOFkak0ruk1zH6dixY+jVqxeOHj2KhIQEVfRJjuMkCAKuX79u1ZiUs09FRUUICAhAcXGx9Pe7ITafARJFEXFxcdBqtfD19YVOp8M999yDoUOH2rorm9x3333466+/TNqmTJmC+Ph4PPvss4iMjESzZs1w4MABjBkzBgBw7tw55OTkoE+fPhb36+7uDnd393rtGo3GpNgCLK8ksLW97n7taa9bgBpxHGd2e1axO7JPlmJ3ZJ84jrN4XVupfWqo3ZF9sjQmldwnOY4TqzHpTH2yFKOt7bb2yc3NTfp/7deV3Cc5jpNGo7FpTDpbnyyxuQD68MMPAdScObl+/TouXLiAjz/+GC+//LKtu7KJj48POnXqZNLm5eWFFi1aSO3Tpk3D3LlzERgYCF9fXzz99NPo06ePqiZAAzUVd25uLlq1amXzASemKJdsUB7ZoVyyYzzbYOvcEGJKrWPS5gJo0qRJZtvffvttzJo1C1OnToWfn59D5wNZsnbtWvA8jzFjxqCiogJDhgzBe++91+RxOJooiigvL6eVDQxQLtmgPLJDuWSHVoGxodYxadckaHOmT58uXXPz8PBgtdsG/fLLLyZfN2/eHO+++y7efffdJvn5hBBCCFEmZgVQ8+bNLZ4dIoQQQghxJjYXQHPnzm3w9TVr1tgdDLEOz/MICwtT1bVYuVAu2aA8skO5ZKfuiiVi6saNG0hLS7vtdjdv3sSZM2dw/fp1q6/wxMfHw9PTs7EhOpTNBdDvv/8u/fu3335DQkKClBDjcljiWBzH1bvhI7EP5ZINyiM7lEt2jH+T6G+TeWlpaUhISHDIvlNSUiw+OcJZ2FwA/fzzz9K/fXx88NlnnyE6OpppUKRhgiAgOzsbbdq0oU82jUS5ZIPyyA7lkh1aBdaw+Ph4pKSk3Ha7M2fO4LHHHsPHH3+MDh06WL1vZ8dsDhBpOqIoorKyUnUz8uVAuWSD8sgO5ZIdWgXWME9PT6vO0hhvjtiuXTunP6tjC/p4QQghhBCXY/MZoF27dkn/FgQBBw4cwKlTp6S2ESNGsImMEEIIIcRBbC6ARo0aZfL1E088If3b3HNECHs8zyMiIoLmBzBAuWSD8sgO5ZIdWgXGhlrzaHMBRJPJ5MdxnPSketI4lEs2KI/sUC7ZoVVgbKg1jzaXcxcuXHBEHMQGBoMB6enpdLaNAcolG5RHdiiX7BhzSLlsHLXm0eYCqG3btrj33nvxySef4NatW46IiViBzsSxQ7lkg/LIDuWSEMezuQBKTU3FHXfcgblz5yIsLAxPPPEEjh075ojYCCGEEEIcwuYCqEuXLnjrrbdw5coVbN68GXl5ebj77rvRqVMnrFmzBteuXXNEnIQQQgghzNg9pdvNzQ2jR4/GV199heXLl+P8+fOYP38+IiMjMXHiROTl5bGMk9TC8zx0Op3qZuTLgXLJBuWRHcolO2pdvdTU1JpHu3tz4sQJPPXUUwgPD8eaNWswf/58ZGZmYv/+/bhy5QpGjhzJMk5Sh5sb3cSbFcolG5RHdiiXhDiezQXQmjVr0LlzZ/Tt2xdXrlzB1q1bcfHiRSxduhQ6nQ79+vXDli1bkJqa6oh4CWomSGZkZNBESQYol2xQHtmhXLJDzwJjQ615tPljxvr16zF16lRMnjwZ4eHhZrcJCQnBBx980OjgCCGEEEIcweYCKCMj47bbaLVaTJo0ya6ACCGEEEIczeYC6OTJk+jSpUu99r///htPP/00PvnkExZxEUKcwI0bN5CWlnbb7crLy3HkyBH07t0bXl5eVu07Pj4enp6ejQ2REELsYnMBdO+992L37t246667pLZvv/0WM2bMQOfOnZkGR8zjeR6xsbGqm5EvB8plw9LS0pCQkOCQfaekpKBbt24O2beS0ZhkR62rl5qaWvNocwG0cuVKPPjgg/jyyy/Rs2dPJCYmYs+ePVixYoXJg1GJY1VXV0Or1codhipQLi2Lj49HSkrKbbc7e/YsJkyYgE8++QTt27e3et/EPBqThDiezQXQv/71L/j6+mLMmDHw9vbGHXfcgb/++gutW7d2RHzEDEEQkJWVhdjYWGg0GrnDUTTKZcM8PT2tOktjfEZQXFwcndVpJBqT7Kh19VJTU2se7brZxLhx4+Dj44OxY8di7NixVPwQQgghRFFsLoDmzp0r/btLly548skncejQIQQGBgKouU8QIYQQQogzs7kA+v3336V/a7Va3HPPPbh48SIuXrwIjuOYBkcsU9tkNDlRLomzoTFJiOPZXAD9/PPPjoiD2ECj0SAuLk7uMFSBcsmGca4KzVlpPBqT7NC4ZEOtebT7Y8b58+fx/fff4+bNmwAAURSZBUUaJooiysrKKOcMUC7ZMOaP8th4NCbZoXHJhlrzaHMBdP36ddx3332Ii4vDgw8+KD31fdq0aZg3bx7zAEl9giDg8uXLqpuRLwfKJRtqXSUiBxqT7NC4ZEOtebS5AJozZw6aNWuGnJwck7u4Pvzww9i3bx/T4AghhBBCHMHmOUA//PADvv/+e0RERJi0x8bG4uLFi8wCI4QQQghxFJvPAJWXl5t9fk9hYSHc3d2ZBEUaxnEctFotrbpjgHLJhjF/lMfGozHJDo1LNtSaR5vPAPXr1w9bt27Fa6+9BqAmIYIgYMWKFbj33nuZB0jq43ke0dHRcoehCpRLNtT6rCA5uPKYzMjIQGlpKbP9nTt3Tvo/q7Hp4+OD2NhYJvtSCrW+v20ugFasWIH77rsPJ06cQGVlJRYuXIjTp0+jsLAQ//3vfx0RI6lDFEUUFxfDz89PdRV5U6NcsqHWVSJycNUxmZGR4bDl/xMmTGC6v/T0dJcqgtT6/ra5AOrUqRPS09PxzjvvwMfHB2VlZRg9ejQSExMRHh7uiBgBAElJSdixYwfS0tLg4eGBvn37Yvny5WjXrp20za1btzBv3jx88cUXqKiowJAhQ/Dee+8hNDTUYXHJQRAE6PV6+Pj4qO6+DE2NcsmGWleJyMFVx6TxzI8tD9S9nfLychw5cgS9e/eGl5dXo/dnfOgvy7NUSqDW97ddzwLz8/PDCy+8wDqWBv36669ITExEjx49UF1djeeffx6DBw/GmTNnpIE9Z84c7NmzB1999RX8/Pwwc+ZMjB49ms5MEUKIQrRv357ZA3UNBgOCg4PpwbLELJsLoA8//BDe3t74xz/+YdL+1Vdf4caNG5g0aRKz4Gqru8R+y5YtCAkJQUpKCu655x4UFxfjgw8+wGeffYaBAwdKsbZv3176BEAIIYQQAthRACUlJWHjxo312kNCQvD44487rACqq7i4GACkh7CmpKSgqqoKgwYNkraJj49H69atcfjwYYsFUEVFBSoqKqSvS0pKANR8cjAYDABqJnrzPA9BEEyugVpq53lemhxurt2439rtQP3Ti5baOY6Dp6enSbsxFlEUzbZbG7tcfdJoNBZjd3SfPDw8TPavhj419XEyzlURRdHu942z9UnO42RuTCq9T7c7TsbXRVGsF6O9fRJF0SSXje1T7Rhrx2ypT7drV9JxMvbb+Lqz9skWNhdAOTk50Ol09dqjoqKQk5Nj6+7sIggCZs+ejbvuugudOnUCAOj1emi1Wvj7+5tsGxoaCr1eb3FfSUlJeOWVV+q1Z2ZmwtvbG0DNJb/w8HDk5+dLhRcABAUFISgoCLm5uSgvL5faw8LC4O/vj+zsbFRWVkrtERER8Pb2RmZmpsmB0ul0cHNzQ0ZGhkkMsbGxqK6uRlZWltTG8zzi4uIQGBiIzMxMqV2r1SI6OhrFxcUm/fXy8kJkZCQKCwtRUFAgtTtjn8rLy3H58uUm75PBYDDJpRr61NTHyfjL8NKlS/D19VVFn+Q8ThUVFSZjUg19ut1xMv79EAQBlZWVTPpUVFSEmzdvSrlsbJ+MMRofAaXGsWeuT0a139/O2Cdb70XIiTZO627dujXeeecdjBgxwqT922+/RWJiokmnHeXJJ5/E3r178dtvv0k3ZPzss88wZcoUk7M5ANCzZ0/ce++9WL58udl9mTsDZDwgxgPtbJ9YOY7D9evX4e/vL23jrJ8anP2TkCiKKCgoQEBAgMlSTyX3SY7jlJqaih49euDo0aNISEhQRZ/kOk6WxqSS+2TNcUpNTUXPnj1x4sQJdOvWjUmfqqurUVhYKOWysX2qHWNCQoLqxp6l43TixAn07NnT5P3tjH0qKipCQEAAiouLpb/fDbH5DNCjjz6KZ555Bj4+PrjnnnsA1ExQnjVrFh555BFbd2ezmTNnYvfu3Th48KDJ3ajDwsJQWVmJoqIik7NA+fn5CAsLs7g/d3d3szdw1Gg09SbN1T4V2Jh2S5PxrG03GAy4fv06AgMD673GcZzZ/bCK3VF9AizH7sg+CYKAwsJCtGjRot7PUGqfGmp3VJ+Mv4zMvabUPjXU7sg+sRqTztQnSzHWbjf+33hJlUWfOI4zm0t7+1Q7Rmv6ZE27Uo6TpZiU0CdLbL6r0WuvvYZevXrhvvvug4eHBzw8PDB48GAMHDgQy5Yts3V3VhNFETNnzsQ333yDn376qd5luISEBDRr1gwHDhyQ2s6dO4ecnBz06dPHYXERQgghRHlsPgOk1Wqxbds2LF26FCdPnoSHhwc6d+6MqKgoR8QnSUxMxGeffYZvv/0WPj4+0nVEPz8/eHh4wM/PD9OmTcPcuXMRGBgIX19fPP300+jTpw+tACOEKILBYMAvv/yCkydPokuXLhgwYAAt3ybEQey6DxBQMwGqKe+EuX79egDAgAEDTNo//PBDTJ48GQCwdu1a8DyPMWPGmNwIUW04jnO5u8Q6CuWSDWP+KI/227FjB+bNm4fs7GyprU2bNli9ejVGjx4tX2AKRu9vNtT6/lbMgz2MSyPr/mcsfgCgefPmePfdd1FYWIjy8nLs2LGjwfk/SsXzPMLDw22+3knqo1yyUXeyLrHNjh07MHbsWHTu3BmHDx9GaWkpDh8+jM6dO2Ps2LHYsWOH3CEqEr2/2VDr+1tdvXERgiAgLy/P5nsekPool2wY80d5tJ3BYMC8efMwfPhw7Ny5Ez179kRpaSl69uyJnTt3Yvjw4Zg/f3691Tnk9uj9zYZa399UACmQ8WGJanswnRwol2yo9WGJTSE5ORnZ2dl4/vnnpaXCxjHJ8zyee+45ZGVlITk5We5QFYfe32yo9f1NBRAhhMgoLy8PAKSbutZlbDduRwhhw+ZJ0Lt27Wrw9bo3SCSEEGJZeHg4AODUqVNmV6yeOnXKZDtCCBs2F0CjRo0y+ZrjOJOboNF1asfjOA5BQUGqm5EvB8olG2pdJdIU+vXrhzZt2mDZsmXYuXOnyZgUBAFJSUnQ6XTo16+f3KEqDr2/2VDr+9uuZfB5eXkIDQ0FAPj4+OCPP/5AdHQ008CIZTzPIygoSO4wVIFyyYZaV4k0BY1Gg9WrV2Ps2LEYOXIkhg4dCg8PD9y8eRP79u3Dnj17sH37drofkB3o/c2GWt/fNhdAtc/4ADWzwjMzM6kAakKCICA3NxetWrVS3YBsapRLNtS6SqSpjB49GvPnz8eaNWuwe/duqd3NzQ3z58+n+wDZyZXf3xkZGSgtLWWyrzNnzpj8nxUfH58mvZ9gXTYXQOHh4UhNTcWDDz6Ic+fOoaKiAuPGjcPy5cvx+OOPOyJGUocoiigvL1fdjHxWbty4gbS0NKu2LS8vx5EjR9C7d294eXnddvv4+Hh4eno2NkTVUesqkaayY8cOrFy5sl57dXU1Vq5cid69e1MRZAdX/V2ZkZGBuLg45vt97LHHmO8zPT1dtiLI5gJo3LhxeOSRR9C3b1+kpKTgH//4BxYsWICxY8fi0KFD2LJliwPCJMR6aWlp0hOLWUtJSUG3bt0csm/imgwGA6ZMmQIA0pOujYxfT5kyBSNHjqTLYMQqxjM/n3zyCdq3b9/o/dn6QdEaZ8+exYQJE5idpbKHzQXQqlWrEB8fjz/++AODBg3CU089BU9PT5w4ccIh1SEhtoqPj0dKSopV254+fRoTJ07E1q1b0bFjR6v2TQhLBw4cQElJCQDggQcewHPPPYfmzZvj1q1bSEpKwp49e1BSUoIDBw5g8ODBMkdLlKR9+/ZMPrAZDAYEBwcjNjZWVUW4zQUQz/NmL3UFBgZiz549TIIiDeN5HmFhYS53Tdtanp6eVr/pjafGO3ToQGd2GkGtkySbwtatWwHU3O9n165d4DgOxcXF8PPzw65du3DHHXfg9OnT2Lp1KxVANqLflWyoNY/q6o2L4DgO/v7+qluSKAe1Lu9sapRH+xkffjp58mTwPG/y/uZ5HhMnTjTZjliPfleyodY82rUMfvv27fjyyy+Rk5ODyspKk9dSU1OZBEYsEwQB2dnZaNOmjeoq8qZGq5fYoDzenqXJ+b6+vgCA9evXo3///rh16xaOHz+OHj16oHnz5ti4caO0nbnfrzQx3zL6XcmGWvNocwG0bt06vPDCC5g8eTK+/fZbTJkyBZmZmTh+/DgSExMdESOpQxRFVFZWutzKBkeg1UtsUB5v73aT8zMzM9GjRw+Lr+/duxd79+6t104T8y2j35VsqDWPNhdA7733HjZt2oRHH30UW7ZswcKFCxEdHY3FixejsLDQETESQojiWZqcbzAYcO+996K8vLzefdaMq8C8vb3x008/mZ2AShPzCbGPzQVQTk4O+vbtCwDw8PCQlrA99thj6N27N9555x22ERJCiAo0NDl/69atGDNmTL12YzH00UcfNXh2iBBiO5sLoLCwMBQWFiIqKgqtW7fGkSNHcOeddyIrK0t1p8ecFc/ziIiIUNW1WLm48uollneKTU9Pl/7Pcpms3HeKbSqjR4/G119/jblz5+LixYtSe1RUFFavXk03QbQT/a5kQ615tLkAGjhwIHbt2oWuXbtiypQpmDNnDrZv344TJ07Qm7SJcBwHb29vucNQBVddveSoO8VOmDCB+T7lvFNsUxo9ejRGjhyJDz74AE888QQ2btyIadOmqeq+K02NfleyodY82lwAbdq0SVrpkZiYiBYtWuDQoUMYMWIEnnjiCeYBkvoMBgMyMzMRExNDvxwbyWAwmPzfVTjiTrFHjx5Fr169VHWn2Kam0WjQtWtXAEDXrl3p/d1I9LuSDbXm0a4bIdY+DfbII4/gkUceYRoUuT1abkxYoDvFErWj35VsqDGPdl3Q+/7773HkyBEAwDfffIOJEyciKSkJVVVVTIMjhBBCCHEEm88ALVq0CCtWrIBGo8Gzzz6L9evXY+DAgVi7di2uXLmCt99+2xFxugRrn2JOTzAnhBBCGsfmAujjjz/Gtm3bEBUVhb59+2LHjh0YMWIEfv75Z0yYMIEKoEZw1FPM6UZplrnyKjCWeJ6HTqejPDJAY5IdGpdsqDWPNhdA+fn5uPvuuxEeHg6tVis9Qbt9+/bIz89nHqArsfYp5sbJodZOYKUbpZGm4OZm15N1CHEoGpdsqDGPNvdIFEUpEW5ublJFWPcOpsR21j7F3LhiKS4ujs7sNBI9w4oNQRCQkZFBk6AZoDHJDo1LNtSaR7sKoLi4OHAch7KyMnTt2hU8z1PxQwghhBDFsLkA+vDDDx0RByGEEEJIk7G5AJo0aZIj4iDEKiwf3wBAWnWXlpbG7NSuqzy+gRBClMyuWU0GgwE7d+7E2bNnAQAdO3bEiBEjVHVt0Jm56ioRRz2+AQAmTpzIdH+u8vgGI57nERsb63Jj0hFc9f3tCDQu2VBrHm0ugM6fP48HH3wQubm5aNeuHQAgKSkJkZGR2LNnD2JiYpgHSQjA/vENAHDz5k2cP38ebdu2hYeHR6P354qPbzCqrq6GVquVOwxCTNC4ZEONebS5AHrmmWcQExODI0eOIDAwEABw/fp1TJgwAc888wz27NnDPEhiytVXibB6fANQczazRYsWqlvd0NQEQUBWVhblkQFXf3+zROOSDbXm0eYC6NdffzUpfgCgRYsWeOONN3DXXXcxDY4QQpydEualATQ3jZC6bC6A3N3dzb7Zy8rKnOb02LvvvouVK1dCr9fjzjvvxNtvv42ePXvKHRYhTiXMm4NHUTpwhcF1fUGAe2EOkHcDYDRPwKMoHWHeHJN9OYqS5qUBrjc3jZCG2FwADR8+HI8//jg++OADqag4evQoZsyYgREjRjAP0Fbbtm3D3LlzsWHDBvTq1QtvvvkmhgwZgnPnziEkJESWmOgTonNT28Q+az2RoEX7g08ABxu/Lw0AXeN3Y6I9amJ0Zo6Yl1ZeXo6jR4+iV69eVj3rzxquPDfNVd/frD/geBRdVt0HHJsLoHXr1mHSpEno06cPmjVrBqBmctSIESPw1ltvMQ/QVmvWrMH06dMxZcoUAMCGDRuwZ88ebN68GYsWLWryeOgTonPTaDQOOz7ObmNKJR5evAXtnfRRKWfT0rBx9T8h/8eq22M5Lw0A+vXrx2xfrsyV39+sP+BENX43JpzhA47NBZC/vz++/fZbZGRkSGci2rdvj7Zt2zIPzlaVlZVISUnBc889J7XxPI9Bgwbh8OHDZr+noqICFRUV0tclJSUAaibHGh85wXEceJ6HIAgmd7y21M7zPDiOgyAIKCoqAgBs3boVHTp0AMdx0n5rbw/Un/Roqb2yshJnz55FXFyctHLJGIsoiibbWxt7WloaJk6ciOLiYulnWuqTufbG9kmj0ViM3dhu/Bm1J4laczwaOk5Azad4T09PcBzX6D4Zv8f4/9v1yd7YrRl7DR0ng8EAfZmIG36xEMPvbPRxMt4Z3sPDQ8pjY/tUllsFfZkobSPn2LMUo71jsqHjBJgfk43pU+0cyT32LMVuMBgQ5s2h+d/nIF7hIAimTxfQ8DxEiCbtHMeB5ziL7QZBwM2bN9G8eXNpnPIcB0EU6/fJTDvPc+Dwv3b3wjSEef/vsU9yjr2G2g0Gg/QBp127dg32qW67oV7sHEQRuHHjhpRHY3tNn+w7Tmlpadi4egJGgM3vcuPYs4XdTzeLjY11ujMFBQUFMBgMCA0NNWkPDQ2VirW6kpKS8Morr9Rrz8zMhLe3NwDAz88P4eHhyM/PlwoEAAgKCkJQUBByc3NRXl4utYeFhcHf3x/Z2dnIyckBUPOcr3bt2sHb2xvp6ekmB0qn08HNzQ0ZGRkmMcTGxqK6uhpZWVlSG8/ziImJgY+Pj8mz2LRaLaKjo1FUVAS9Xi9t7+XlhcjISBQUFKCgoEBqN/YpLy8PxcXF8PT0BACpfw31qbKyUmqPiIiAt7c3MjMzG9WnuLg4lJeX4/Lly1K7sU/FxcXQ6/VSLq9evQoAKCwsNNsnW46Tj48PTp8+DT8/PymXjemTMcbLly+jR48et+1T3ePEok/WHCdjnFVVVdJzfhpznKKiopCZmQmtVivlsbF9MsZYVlYGALKOPUvHKScnB2HeHCovHgdauuF6QYEUL1DzgTHA3x9X8/Nx8+bNWn1tAR9vH1zJzUVVVZXUHhoaCnd3d1z46y/4+vpKf2xatWoFjUYj5cSodevWMBgMyM3NNelTVOvWuHnzpvSA6pILF6TLDXKPPUvHKScnB08kaNEheQaQXHPWoS4OtrVrAHibabd0Eed27R1Rc9bCeCzlHHtG5o5TTk4O9GUibvrHIVcIMn+cLlwwf5zM/H3iOA4njx1DYKCH9P5usE9lZeb7VOvvU1qxO/RlNUUMq7F38eJF2IITbXyI1+jRoxt8fceOHTYFwNKVK1fQqlUrHDp0CH369JHaFy5ciF9//RVHjx6t9z3mzgAZB5mvry+AxlWjKSkpGDGwF3785hN06NDeYoUN1K+kLbUDQM7Fi4iIjADPa/4XSwOfhG73iSctLQ2DHpqA//x8DN27d3fKM0Cpqano2bMnjh8/bjZGe46TIAhIT09HTEyMNJ+qMX0yxnjs2DH06NHDac8AGeM8ceIEunXr1ujjJIpivTw2tk+1Y0xISHDKM0CpqanYs6AfXh7gDmf38i8VGLHmELp27eqUZ4BSU1MxYmAvHNj5Kdq3j2dyBqiquhqXLl1C5P//XdnYM0DG35O7fzmOhIQEpz0DZHzvpKSkoEuXLo0+TgaDAenp6Wjbtq3J78nG9KmhGO0de0VFRQgICEBxcbH097shNp8B2rlzJ8aNG8fkpnGsBQUFQaPRSJ96jPLz8xEWFmb2e9zd3eHuXv+Xl0ajqTfB2NJkuobaNRoNnkjQouNvTwK//f99W4jflnZLE04tfRKy9pPN7e5Ca6nd0mRsW9o5jmuwve4bz57jYU7d/dsTu7Hd+FrtIsCWvrLq0+2OU+34LMVSe7vazG1vMBgs5tHe2GvHaE2fGtNu73HSaDTM51IZ/v8ZutatW0Njoc+2qj2fSu6xZ6ldo9FAXybiVkA7cC27MjkDxBsMqLzhDb6V6f1r7D0DVHEV0JeJ0piUc+w11G7SVwbHyVh4WPt70po+NSZGW9stsesS2Lp162RbUdUQrVaLhIQEHDhwAKNGjQJQU50eOHAAM2fOlC0u1r8gBVHElStX0LJlS/Acm1n0SppwyhLHcdBqtdIvNGIfV86j8VIDWnZhsj9OECBW+oNr2YbZipubekG63OBKXHlcsqTWPNpcABk/MTqruXPnYtKkSejevTt69uyJN998E+Xl5dKqMDmw/gXJA4ho1ZXJvoyU8guS6dJO1OQyujkA/Z9M9ucMSzvlwPM8oqOj5Q5DFSiX7FAu2VBrHm0ugERRxH333QcPDw94eXmhZcuW6Nq1Kx5++GFEREQ4IkabPPzww7h27RoWL14MvV6PLl26YN++ffUmRiuZKIooLi6Gn5+fUxejjsByaacjOMPSTjm48phkjXLJDuWSDbXm0eYCaMmSJRBFEVVVVSgpKcGVK1fwzjvvYMmSJdi/f7/J5GO5zJw5U9ZLXo4mCAL0ej18fHxU9VwWazj7fAtXvZToymOSNcolO5RLNtSaR7sKoLpEUcS//vUvPP/88/j555+ZBKYWN27cAFAz452V8vJyHDlyBL1792Z6p1glYH05EQYDKso8gfBYgMEbWymXEgkhxNXZfR+g2jiOwyuvvOIUd4J2Nsb7D02fPl3mSKzj4+MjdwiEKAZ9wCFEuWwugM6cOYP4+Ph6y80iIiKwcuVKZoGphXE1Wnx8vHSzwcY6c+YMHnvsMXz88cfo0KEDk30CrvksMI7j4OXlparr2nJw1TzSBxzn5qrjkjW15tHmAqhz587Iy8tzymXwzigoKAj/+te/HLLvDh06MH3+kCvieR6RkZFyh6F4rppHR3zAMT64lOUDVgHX/IDjquOSNbXm0a5VYERetZ87RBpHEAQUFhYiMDDQ5ptokf9x1Tw64gOO8X3drl07+oDTSK46LllTax6ZzAEiTctYhLpaMaqE+RauOtdCFEUUFBQgICBA7lAUz1Xf345A45INtebRrhshlpaWonnz5mZft+b5G4TYQ0nzLZx9rgXrYpIm7hJClMauS2BxcXFm2809SI0QVhwx3+L06dOYOHEitm7dio4dOzLZpxLmWlAxSQhxdTYXQHSfH/kZZ+KrbUb+7ThyvkX79u1dar4F62KSViay46rvb0fgOE51dy+Wg1rzaHMB1L9/f0fEQWxwu6ehE+u5ai4dtTqRViY2nquOSUfgeR7h4eFyh9HkWF/ivnnzJrKzs9GmTRt4eHgw2aczXOK2uQDS6XSYMmUKJk+ejNatWzsiJnIbtAqMHcolG5RHdiiX7AiCgPz8fISGhrpUQUmXuK1jcwE0a9YsbNmyBa+++iruvfdeTJs2DQ899BDc3d0dER8xg1aJsEO5ZIPyyA7lkh3jQzxd7b51rC9xO2KuJCD/JW6bC6DZs2dj9uzZSE1NxZYtW/D000/jqaeewj//+U9MnTqVTn87mMFgQEpKCgAgJSUF3bp1U9XD6QghhDQO60vcxsVN8fHxqvobb/c5wW7dumHdunW4cuUKlixZgvfffx89evRAly5dsHnzZvr04gA7duxATEwMnnzySQDAk08+iZiYGOzYsUPmyAghhBBlsbsAqqqqwpdffokRI0Zg3rx56N69O95//32MGTMGzz//PMaPH88yTpe3Y8cOjBkzBjk5OSbtOTk5GDNmDBVBdqIVN2xQHtmhXLLDcRyCgoIol42k1jFpcwGUmpqKp59+GuHh4Zg5cyY6duyIU6dO4bfffsOUKVPw0ksv4ccff8Q333zjiHhdksFgwNSpUwEAwcHBePHFFwEAL774IoKDgwEAU6dOpXsw2YFW3LBBeWSHcskOz/MICgqiXDaSWsekzXOAevTogfvvvx/r16/HqFGj0KxZs3rb6HQ6PPLII0wCdCU3btyQZu/XduTIERQXF8PX1xc7d+7E7t27AdSscNi5cyeGDBmC4uJibNy4Eb179673/SxvHKg2tOKGDcojO5RLdgRBQG5uLlq1aqW6P95NSa1j0uYC6MKFC4iKimpwGy8vL3z44Yd2B+Wq0tLSkJCQYPH1kpIS9O3bV/p62bJlWLZsmfR1YmKi2e8zTpYm9dGKGzYoj2wYDAacOHECAHDixAl07dqVFjk0giiKKC8vp3HZSGp9f9tcAN2u+CH2i4+Pl1Z41TZv3jz88ssv4DgO/fr1w6OPPoqCggIEBQXh888/R3JyMkRRxIABA7B69Wqz+yWEOLcdO3Zg7ty5uHjxIoCaRQ5vvPEG1qxZg9GjR8scHSHqQ0+DdyKenp5mz9QMGzYMv/zyC3x8fHDgwAFwHIeMjAzExsbiX//6FwIDA1FaWophw4bRmR5CnJSlS9wA8NNPP2HBggXQarUm7Xl5eRgzZgxWrlyJgQMHmv1eusRNiH2oAFKAO++8E0DNJbCHHnoIzz33HCIjI3H06FEkJSWhtLTUZDtiPbVO7mtqlMfbu90lbgCorKw0+/WCBQssfg9d4raM53mEhYXRuGwktb6/qQBSgIKCAunf3333nTQJGoDJ/IDa2xHrqHV5Z1OjPN6epUvcx44dk+7t1ZD169ejZ8+eZvdLzOM4Dv7+/nKHoXhqfX9TAaQAxof5jR8/Hl988UW91//5z3/is88+c8mH/jWWWlc3NDXK4+1ZusT99ddfW/X9ly5dwowZM1iHpWqCIEgP8VTb2YumpNb3N9MR8eqrryI5OZnlLgmAfv36oU2bNigpKUFZWRlWrVqF8ePHY9WqVSgrK0NpaSl0Oh369esnd6iKo9bVDU2N8mi/CxcuMN2O/I8oiqisrKRx2UhqfX8zLYA+/PBDDBkyBP/3f//HcrcuT6PRYPXq1di9ezfGjRuHXr16Yc6cOejVqxfGjRuH3bt3Y9WqVbRclhAFys/PZ7odIcQ6TC+BZWVl4ebNm/j5559Z7pYAGD16NLZv34558+aZnOnR6XTYvn07LZMlRKH0ej3T7Qgh1mE+B8jDwwMPPvgg690S1BRBI0eOxMGDB6Xr2vfccw+d+WkEta5uaGqUR/uVl5dbfI3jOOmyQ0PbEfN4nkdERASNy0ZS6/vb7gLoxo0byMnJqbds84477mh0UMQyjUaDe++9V+4wVEOtqxuaGuXRMdQ256KpcRwHb29vucNQPLW+v20ugK5du4YpU6Zg7969Zl+nB3I6nsFgQGZmJmJiYujsTyMZxyuN28ahPNrPx8eH6Xbkf+h3JRtqfX/bfD5r9uzZKCoqwtGjR+Hh4YF9+/bho48+QmxsLHbt2uWIGIkZaluOSIir6tSpE9PtiCn6XUkssbkA+umnn7BmzRp0794dPM8jKioKEyZMwIoVK5CUlOSIGAkhRLW6d+/OdDtCiHVsLoDKy8sREhICAAgICMC1a9cAAJ07d0Zqairb6AghROVCQ0OZbkcIsY7NBVC7du1w7tw5ADXPntq4cSNyc3OxYcMGh92JODs7G9OmTYNOp4OHhwdiYmKwZMmSehOw//zzT/Tr1w/NmzdHZGQkVqxY4ZB45MbzPHQ6nepm5MtBrasbmhrl0X5Xr15luh35H/pdyYZa3982T4KeNWsW8vLyAABLlizB0KFD8emnn0Kr1WLLli2s4wNQ8xBBQRCwceNGtG3bFqdOncL06dNRXl6OVatWAah5UOjgwYMxaNAgbNiwAX/99RemTp0Kf39/PP744w6JS05ubvQUE0LUwPgMP3d3d1RVVZnMWeF5Hs2aNUNFRQU9689O9LuSWGLzyJgwYYL074SEBFy8eBFpaWlo3bo1goKCmAZnNHToUAwdOlT6Ojo6GufOncP69eulAujTTz9FZWUlNm/eDK1Wi44dO+LkyZNYs2aN6gogQRCQkZGB2NhYWtnQSGp9xk1Tozza7/LlywCAiooKhIaG4p///Ce8vb1RVlaGzz77TLoDtHE7Yj36XcmGWt/fjS6Naz/g7+rVq9L8IEcrLi5GYGCg9PXhw4dxzz33QKvVSm1DhgzB8uXL8ffffyMgIMDsfioqKlBRUSF9XVJSAqBmuZ9xyR/HceB5HoIgmNyXw1I7z/PgOM5ie92lhMbTinUHl6V2oOb+ILX3Y4xFFEWT7W2NXa4+aTQai7Hb2qeysjKcPXvWqj6lpaUBAM6cOWNVn+Lj49G8efMm75OzHycjQRDsft84W5+a6ji1atUKAODl5QUPDw+sXbtW2q5Nmzbw9PTEjRs3EBERYXVf5e6TPcfJ+LooivVibEyfGjMm6/apdoy1Y7bUp9u1K+U4GbernUtn7ZMtbC6AFi9ejFdffbVe+6efforZs2dLk6Id6fz583j77belsz9AzW3idTqdyXbGSYN6vd5iAZSUlIRXXnmlXntmZqZ0Ay0/Pz+Eh4cjPz8fxcXF0jZBQUEICgpCbm6uyV1aw8LC4O/vj+zsbJN5ShEREfD29kZmZqbJgdLpdHBzc0NGRoZJDLGxsaiurkZWVpbUxvM8YmJiUFVVhfPnz0uDUKvVIjo6GsXFxSa3zPfy8kJkZCQKCwtNTqE7W5/i4uJQXl5u8inX3j7997//NTljaI3Jkydbtd2xY8fq3Y+lKfrk7MfJ6NKlS/Dz81NFn5rqOBmVl5ejX79+mDt3LvLy8sDzPH777Tdpm8DAQMX0yZ7jlJOTA6DmD2plZSWzPhUWFkq/KxvbJ2OMN2/eBADFjz1rj5Ox2Kj9/nbGPl28eBG24EQbbzXaunVrPPTQQ3jrrbcA1Jz1efzxx/Hbb7/hzTffNLlEdjuLFi3C8uXLG9zm7NmziI+Pl77Ozc1F//79MWDAALz//vtS++DBg6HT6bBx40ap7cyZM+jYsSPOnDmD9u3bm92/uTNAxgPi6+sLwPk+sQJAenq6yc29nPFTgy19kusM0I0bN3DkyBH07NkTnp6et+0TnQEy36eUlBT07NkTR44ckZZrK71PTXWcPv30U0ycOBFAzaOEjH9c63798ccf49FHH1VEn+w5TqmpqejZsydOnDiBbt26MelTVVUVMjIy0LZtW2g0mkb3qXaMCQkJih971h6n48ePo1evXibvb2fsU1FREQICAlBcXCz9/W6IzWeAkpOTcf/996OoqAj3338/Zs2ahbvvvhunTp1CWFiYTfuaN2/ebT95R0dHS/++cuUK7r33XvTt2xebNm0y2S4sLKze05KNXzcUl7u7O9zd3eu1azSaeteMjQe8LlvbLV2LtrZdFEXExcVJB702juPM7odV7I7qE2A5dlv75O3tjR49eph9rbbKykq8++67yM7OhpubGxITE03OZtjKkX1y9uNk/Hlubm4Oe98oYezZ0x4ZGSn9LHOfR43tERERiumTtTHWbq/9Yc7W2C21u7m5oV27dvV+V9rbp9oxWtMna9qVcJyMbebe30rokyU2F0BRUVE4ePAgBg8ejE8++QQbN27Ev/71L1t3AwAIDg5GcHCwVdvm5ubi3nvvRUJCAj788MN6He3Tpw9eeOEFVFVVoVmzZgCA/fv3o127dhYvfylZdXV1o/5Yu7qFCxdi7dq1qK6uNmmbM2eOam+fQJxTv3790KZNGwQFBaGgoMDkslhYWBhatGiB69evo1+/fvIFqWD0u5JYYtei/rCwMBw8eBC9evXCtm3bTE7ZOkJubi4GDBiA1q1bY9WqVbh27Rr0er3JtcR//vOf0Gq1mDZtGk6fPo1t27bhrbfewty5cx0amxwEQUBWVpbNE75IjYULF2LlypVo0aIF5syZg5deeglz5sxBixYtsHLlSixcuFDuEBXHOBZpTNpOo9Fg9erVSElJQadOnbBu3TosXboU69atQ8eOHZGSkoJVq1bRKiY70O9KNtT6/rb5DFBAQIB0+q+qqkq6M7TxrEthYSHbCFFzJuf8+fM4f/48IiIiTF4znjL28/PDDz/8gMTERCQkJCAoKAiLFy9W3RJ40jiVlZVYu3Yt/Pz80Lx5c5MVN1FRUfDz88PatWuxdOlS+tRImszo0aOxfft2zJs3D7t375badTodtm/fjtGjR8sYHSHqZHMB9OabbzogjIZNnjzZqlU6d9xxB5KTkx0fEFGs9957D9XV1SguLsY999yDTz/9FM2bN8etW7ewfPly/Oc//5G2mz17trzBEpcyevRojBw5Er/88gtOnjyJLl26YMCAAXTmhxAHsbkAmjRpkiPiIDaydbIXqWFcnnr//fdj586dEEURmZmZ6NKlC3bu3ImhQ4di//799ZaxEtIUNBoNBgwYgMjISJNVnsR+9LuSWGLXjRArKirw6aef4syZM+A4Dh07dsSjjz5qdjUVYU+j0SAuLk7uMBTJePk2ISFB+sVYO5ddu3bF/v37662uIw2ru5KH2I/e3+xQLtlQ6/v7tqVxdXU1IiIipBscnjlzBrGxsZg/fz5SUlJw4sQJzJ07F3FxcdJddYljiaKIsrIys0tmScN69eoFANi8eTOqq6tNclldXS09z864HbGOcSzSmGw8en+zQ7lkQ63v79ueAXJzc0NZWRlKS0sRHByMWbNmoXv37ti6dat0p+TS0lJMnDgRs2bNwvfff+/woF2dIAi4fPkyPd/GDsZ7rly9ehURERF4+eWX0aFDB5w5cwYvv/yy9MRt43bEOmpdJSIHV31/37hxA0DNDRFZKS8vx5EjR9C7d294eXk1en+1b7DqStT6/rbqElhQUJA0OA8dOoRjx45JxQ8A+Pj44NVXX0WfPn0cEyUhjBjvuaLRaJCdnY0nn3xSes3NzQ0xMTEQBIHuuUJIEzNeQZg+fbrMkdxe3cfhEGWyqgDq2rUr9u7di06dOsHf3x9FRUX1tikuLqZlw8TpGe+5MnbsWDz44IOIjo6GXq9HWFgYLly4gO+++w7bt293qU/ehDiDUaNGAQDi4+Olx9I01unTpzFx4kRs3boVHTt2ZLJPHx8fxMbGMtkXkZdVBVBiYiJGjhyJhIQEjBo1Ck888QQ++OAD9OzZEwBw9OhRzJgxA8OGDXNosKQGx3HQarU0UddOte+5smfPHqmd7rliP+NYpDHZeK76/g4KCrL7qQKWGC/ZtG/fHt26dWO6b1ei1ve3VQXQgAED8N5772Hs2LHw8PBAXl4e+vbtCze3mm+vrq7G0KFDpQekEsfied7kGWnEdsZ7riQnJyMvLw/h4eHo168fnfmxk3FFHS05bjx6f7ND45INtebR6mXw48ePx6hRo5CcnIxr165JlXVAQADi4+NpqWETEkURxcXF8PPzU11F3tREUUR5ebnqVjc0NbWuEpEDvb/ZoXHJhlrzaNN9gLy8vDB06FBHxUKsJAgC9Ho9fHx86IyFnXbs2IF58+aZPHiyTZs2WL16NV0Cs4NaV4nIgd7f7NC4ZEOtebT5Rojr1q1r8PVnnnnG7mAIaQo7duzA2LFjMXz4cHzyyScmj8IYO3YszQOykcFgQEpKCgAgJSUF3bp1oz/chBCnZ3MBNHv2bHh6eiIkJKTe6TCO46gAIk7NYDBg3rx5GD58uPQojIyMDOlRGKNGjcL8+fMxcuRI+iNuhbpn0p588kksX76czqQRQpyezQXQCy+8gLfeeguDBg3Ca6+9htDQUEfERRrAcRy8vLxofoAdkpOTkZ2djc8//xw8z0MQBCmXPM/jueeeQ9++fZGcnIwBAwbIHa7sbty4YfEO7z/99BMWLlyIu+++G/3798dHH32ESZMm4cKFCxg7dixWrFiBgQMHWtw3y+XOakLvb3bUunqpqak1jzYXQK+99hpmzJiBF154Ae3atcOCBQswf/58eg5YE+J5nu5UbKe8vDwAQKdOnQDUz6Wx3bidq0tLS0NCQkKD2yQnJyM5ORkA8NFHH0ntCxYsaPD7jJfLiCl6f7Oj1tVLTU2tebTrYaitWrXCli1bkJqaivnz52PDhg14/fXXMXHiRNbxETMEQUBhYSECAwNVNyAdLTw8HABw6tQp9OjRA7/++ivOnz+Ptm3bon///jh16pTJdq4uPj5emt9T24kTJ/DEE0/c9vs3btyI7t27W9w3qY/e3+yodfJuU1NrHm0ugP7888//fbObG9588018++23mDlzJt566y2zvywJW6IooqCgAAEBAXKHojjGR2E8/fTTyM/Px6VLl6TXIiMjERoaCp1OR4/C+P88PT3NnqWp/UykkJAQjB8/Hj4+PigtLcWnn34qPVPNy8uLzvLYiN7f7Kh1+XZTU2sebS6AunTpAo7jpETU/vfJkyeZBkcIaxqNBv/4xz+wcuXKeq9dunQJly5dwoIFC2gC9G1cuXIFAODh4YHmzZtj7dq10mutW7eGh4cHbt68KW1HCCHOxuYCKCsryxFxENIkDAYDNm7cCADSJGgj49cbN25EUlISFUEN+OOPPwAAN2/exLVr10xeu3btGm7evGmyHSGEOBubC6CoqChHxEFswHEc3SXWTgcOHEBJSQm8vb0RGBiInJwc6bWIiAgUFhaipKQEBw4cwODBg2WM1LmVlZVJ//bx8cHatWvRq1cvHD16FIsXL5YKoNrbEevQ+5sdta5eampqzaPNBdCuXbsafH3EiBF2B0Osw/M8TdK108cffwyg5g/zvffei23btqFTp044deoUli1bhv/85z/SdlQAWRYWFgYAcHd3R/PmzTFjxgzptaioKGi1WlRWVkrbEevR+5sdta5eampqzaPNBdCoUaMsvsbzPKqrqxsTD7GCIAjIz89HaGio6gako5WWlgIAevbsiZ07dwIA8vPzpa979+6N48ePS9sR84wTdCsqKtCpUyfMnz8fVVVVaNasGfbt24eLFy+abEesR+9vdtS6eqmpqTWPNhdAlhJw69YtuqlZEzE+LDEkJETuUBTH+Mn6+vXrAExzyXGc1E6fwBvm5va/Xx379u3Dd999J31de+5U7e2Idej9zY5aVy81NbXmkdnHC47jVHd9kKhP3759AQCZmZkYMWIEDh8+jPLychw+fBgjRozAhQsXTLYj5hnvkt2qVat673uO49CqVSuT7QghxNnQxzPiUmrfYXfv3r3Ys2eP9HXtMxd0J96GDRgwAMHBwcjNzYW7uzsMBoP0mkajQW5uLkJCQqgAIoQ4LZsLIJ1OZ/ZMj9pOjTkzjuMQFBREZ9zsYLwRokajkR7gacRxHGJiYiAIAt0I8TY0Gg0mT56MlStXoqqqyuQ14zzASZMm0a0E7EDvb3bUunqpqak1j3Y9Dd6cqqoqPPvss42Nh1iB53kEBQXJHYYiaTQarF69GmPGjDF75iIzMxNff/01/eG+DYPBgK+++grdu3fH1atX691OIDg4GNu3b6f7KdmB3t/sqHX1UlNTax5tLoBmzZpltv3WrVtUADURQRCQm5uLVq1aqW5ANhXj099r02g0qvuE4yjJycnIzs7G559/Lj1T7cyZM+jQoQP69++PY8eOoW/fvkhOTqbLYDai9zc7al291NTUmkemk6BJ0xBFEeXl5XTZ0Q4GgwHz5s3D8OHDUVxcjB9//BGrVq3Cjz/+iKKiIgwfPhzz5883OTNE6svLywMAdOrUCRqNBv3798egQYPQv39/aDQadOrUyWQ7Yj16f7Oj1tVLTU2tebT5DNC6devMttP9f4gS1D5z0axZMwwYMACtWrVCbGwsNBoNnnvuOTpzYQXjbQJOnTqF3r1713v91KlTJtsRQpzPjRs3kJaWdtvtjNukpaVZfUk7Pj7e6W+NY3MBVPuhh3W1bt26UcEQ4mi1z1yYQ2curGOcTL5s2TLphpJGgiAgKSkJOp2OJpMT4sTS0tKQkJBg9fYTJ060etuUlBR069bNnrCaDD0MVYF4nkdYWBjND7BD3TMXdXNJZy6sY5xMPnbsWIwaNQqLFi1CZGQkjh49ijfeeAO7d+/G9u3baQK0Hej9zY5aJ++yEh8fj5SUlNtud/PmTWmOn4eHh9X7dnacaOdFvYKCAgBQ3WqFkpIS+Pn5obi4GL6+vnKHQxgzGAxo27YtOnfujJ07d5r8YhQEAaNGjcKpU6eQkZFBf7ytsGPHDsybN8/klgI6nQ6rVq3C6NGj5QuMEACpqalISEhQxNkI0ni2/v22qSwuKipCYmIigoKCEBoaitDQUAQFBWHmzJkoKiqyN2abVFRUoEuXLuA4DidPnjR57c8//0S/fv3QvHlzREZGYsWKFU0SU1MTBAEXLlxQ3Yz8pmA8c7F7926MGjUK//3vf/Hnn3/iv//9L0aNGoXdu3dj1apVVPxYafTo0Th//jwOHDiAtWvX4sCBA8jIyKDipxHo/c2OWlcvNTW1jkmrL4EVFhaiT58+yM3Nxfjx49G+fXsAwJkzZ7BlyxYcOHAAhw4dcvjDDxcuXIiWLVvijz/+MGkvKSnB4MGDMWjQIGzYsAF//fUXpk6dCn9/fzz++OMOjampiaKIyspK1c3IbyqjR4/G9u3bMW/ePNx9991Su06nw/bt2+mPt42Mq8BatmwpTSYn9qP3NztqXb3U1NQ6Jq0ugF599VVotVpkZmYiNDS03muDBw/Gq6++2uAk6cbau3cvfvjhB3z99dfYu3evyWuffvopKisrsXnzZmi1WnTs2BEnT57EmjVrVFcAkcYbPXo0Ro4ciV9++QUnT55Ely5dMGDAAPrjTQghLsLqAmjnzp3YuHFjveIHAMLCwrBixQrMmDHDYQVQfn4+pk+fjp07d5pdWnf48GHcc8890Gq1UtuQIUOwfPly/P333xbPTFVUVKCiokL6uqSkBEDNXBHjvWCMN80TBMGkArbUzvM8OI6z2F73HjPGeSh1Ty9aagdqKvLa+zHGIoqiyfa2xi5XnzQajcXYHdmnAQMGoGXLloiJiQFQc9yV3qemPk6CIODgwYP4/fffceedd0r3AlJyn+Q8TsYYa/dL6X2S6zgZ4zDmUw19kuM4GWOxZkzK3SdbWF0A5eXloWPHjhZf79SpE/R6vU0/3FqiKGLy5MmYMWMGunfvXu8ZTgCg1+uh0+lM2ozFml6vt1gAJSUl4ZVXXqnXnpmZCW9vbwCAn58fwsPDkZ+fj+LiYmmboKAgBAUFITc3F+Xl5VJ7WFgY/P39kZ2djcrKSqk9IiIC3t7eyMzMNDlQOp0Obm5uyMjIMIkhNjYW1dXVJivveJ5HbGwsWrRogczMTOkGlFqtFtHR0SguLjY5Dl5eXoiMjERhYaE0cd0Z+xQXF4fy8nJcvnxZam+KPvn5+QGASS6V3qemPE4//PADVq5cadLHVq1aYeHChXjooYcU2SdA3uPk5eUFQRBMxqTS+yTXcSotLQUAXL58GX5+fqrokxzHSaPRoLq62mRMOmOfLl68CFtYvQqsVatW2LZtm8mcidqSk5Px8MMP48qVK1b/8EWLFmH58uUNbnP27Fn88MMP+PLLL/Hrr79KD7HU6XT4/fff0aVLFwDA4MGDodPpsHHjRul7z5w5g44dO+LMmTPSnKW6zJ0BMh4Q4yxy+tRAfaI+1e/TN998g3HjxmHYsGF44YUX0LFjR/z555944403sGfPHnz55ZcYO3asovpUNxY1HCdX7tOJEyfQo0cPHDt2DN26dVNFn9R4nFj1qaioCAEBAVavArO6AJo6dSoyMzOxf/9+k8tMQE0RMWTIEERHR2Pz5s3W7A4AcO3aNVy/fr3BbaKjozFu3Dj85z//MXnchsFggEajwfjx4/HRRx9h4sSJKCkpMbkp288//4yBAweisLDQ6snZSlgGbzAYkJmZiZiYGJqz0kiUS/vUvZ2AKIpSHjmOo9sJNAKNSXaOHz+Onj174tixY+jRo4fc4SiWUsakrX+/bZoE3b17d8TGxiIxMRHx8fEQRRFnz57Fe++9h4qKCnz88cc2BRscHIzg4ODbbrdu3TosXbpU+vrKlSsYMmQItm3bhl69egEA+vTpgxdeeAFVVVVo1qwZAGD//v1o166dw1emycHWa53EMsql7Wo/UoTneRgMBimPPM/TI0UaicYkcTZqHJNWF0ARERE4fPgwnnrqKTz33HPS6SeO43D//ffjnXfeQWRkpEOCrPuIDePcnJiYGERERAAA/vnPf+KVV17BtGnT8Oyzz+LUqVN46623HLoqjRBXVfuRIgaDod5qOnqkCCHE2dn0KAydToe9e/fi77//liZ5tW3bFoGBgQ4JzhZ+fn744YcfkJiYiISEBAQFBWHx4sW0BJ4QBzA+KuSdd97Bxo0bTRYmtGnTRnrf0SNFCCHOyu5HYaiVEuYAGW9KpdVqTeZFEdtRLu1jMBjQsmVLXL16FcOHD8fzzz+PuLg4pKenY9myZdi9ezdCQkJw5coVp54z4IxoTLKTkpKC7t2748SJEzY99JOYUsqYdOijMIjzcHOz+Tm2xALKpX1qf3YSRVFa/UEaj8YkcTZqHJNUACmQIAjIyMhQ5aS0pka5tE9ycjKuXbuGpKQknDp1CnfddRcCAgJw11134fTp01i2bBmuXr2K5ORkuUNVHBqT7BhzSLlsHLWOSSqACCE2M05unjlzJs6dO4dVq1Zh/PjxWLVqFdLS0jBz5kyT7QghxNmo75wWIcThLE2C/vTTT/HOO+/QJGhCiNOjM0CEEJv169cPwcHBeO6559CpUyf89ttvOHHiBH777Td06tQJzz//PEJCQtCvXz+5QyWEELOoAFIg4/PAjLciJ/ajXNqv9moQjuOku0CTxqExyY4xh5TLxlHrmFRXb1xIdXW13CGoBuXSdsnJybh69SpNgnYQGpPE2ahxTFIBpECCICArK0t1M/LlQLm0T+1J0OfPn8ePP/6IVatW4ccff0RGRgZNgm4EGpPs0CowNtQ6JmkSNCHEZsbJzadOnULv3r0xYMAAtGrVCrGxsdBoNDh16pTJdoQQ4mzoDBAhxGb9+vVDmzZtsGzZsnqfCgVBQFJSEnQ6HU2CJoQ4LSqAFEptk9HkRLm0nUajwerVq7F7926MGjUKhw8fxo0bN3D48GGMGjUKu3fvxqpVq+gxGHaiMUmcjRrHJF0CUyCNRoO4uDi5w1AFyqX9Ro8eje3bt2PevHkmZ3p0Oh22b9+O0aNHyxidctGYZMdYgFMh3jhqHZNUACmQKIooLy+Hl5cXLTtuJMpl44wePRrDhw/Hu+++i7S0NMTHxyMxMRFarVbu0BSLxiQ7xmfT0TPqGketY1J957RcgCAIuHz5supm5MuBctk4O3bsQLt27TB37lxs2rQJc+fORbt27bBjxw65Q1MsGpPs0CowNtQ6JqkAIoTYZceOHRg7diw6d+5scifozp07Y+zYsVQEEUKcGhVAhBCbGQwGzJs3D8OHD8fOnTvRu3dveHl5oXfv3ti5cyeGDx+O+fPnw2AwyB0qIYSYRQWQAnEcB61Wq6prsXKhXNonOTkZ2dnZeP7558HzvEkeeZ7Hc889h6ysLLoTtB1oTLJjzCHlsnHUOiZpErQC8TyP6OhoucNQBcqlfYx3eO7UqROA+nk0ttOdoG1HY5IdehYYG2odkzQqFEgURRQVFdHKBgYol/apfSdooH4e6U7Q9qMxyQ6tAmNDrWOSCiAFEgQBer1edTPy5UC5tE/dO0HXziPdCbpxaEyyQ6vA2FDrmKQCiBBiM3N3gi4vL6c7QRNCFIPmABFC7EJ3giaEKBkVQArEcZzq7sgpF8pl44wePRojR47Er7/+ijNnzqBDhw7o378/nflpBBqT7NAqMDbUOiapAFIgnucRGRkpdxiqQLlsPI1Gg4EDB2LgwIFyh6IKNCbZoVVgbKh1TNKoUCBBEFBQUKC6CWlyoFyyQXlkh3LJDk2CZkOtY5IKIAUSRREFBQWqW5IoB8olG5RHdiiX7NAyeDbUOiapACKEEEKIy6ECiBBCCCEuhwogBeI4Dn5+fqqbkS8HyiUblEd2KJfs0CowNtQ6JmkVmALxPE+PGGCEcskG5ZEdyiU7tAqMDbWOSRoVCiQIAvLy8lQ3I18OlEs2KI/sUC7ZoVVgbKh1TFIBpECiKKK4uFh1M/LlQLlkg/LIDuWSHVoFxoZax6SiCqA9e/agV69e8PDwQEBAAEaNGmXyek5ODoYNGwZPT0+EhIRgwYIFqK6ulidYQgghhDgtxcwB+vrrrzF9+nQsW7YMAwcORHV1NU6dOiW9bjAYMGzYMISFheHQoUPIy8vDxIkT0axZMyxbtkzGyAkhhBDibBRRAFVXV2PWrFlYuXIlpk2bJrV36NBB+vcPP/yAM2fO4Mcff0RoaCi6dOmC1157Dc8++yxefvllaLVaOUJ3CI7jEBQUpLoZ+XKgXLJBeWSHcskOrQJjQ61jUhEFUGpqKnJzc8HzPLp27Qq9Xo8uXbpg5cqV6NSpEwDg8OHD6Ny5M0JDQ6XvGzJkCJ588kmcPn0aXbt2NbvviooKVFRUSF+XlJQAqDmjZDAYANQcfJ7nIQiCyTVQS+08z4PjOIvtxv3WbgfqT9Sz1K7RaNCiRQsIglAvRlEUTba3NXY5+2Qpdkf2ied5BAYGQhRFqQ9K75Ncx8nSmFRyn+Q4TjzPIyAgoN6YVHKf5DpORsZcqqFPchwnjuOsHpNy98kWiiiALly4AAB4+eWXsWbNGrRp0warV6/GgAEDkJ6ejsDAQOj1epPiB4D0tV6vt7jvpKQkvPLKK/XaMzMz4e3tDQDw8/NDeHg48vPzUVxcLG0TFBSEoKAg5Obmory8XGoPCwuDv78/srOzUVlZKbVHRETA29sbmZmZJgdKp9PBzc0NGRkZJjHExsaiuroaWVlZUhvP82jbti0yMzNRXV0tVeRarRbR0dEoLi426a+XlxciIyNRWFiIgoICqd3Z+hQXF4fy8nJcvnxZam+KPvn6+uLkyZPw8PCQcqn0PslxnNq0aYOMjAwIgiDlUel9kus4eXp6IjU1Fd7e3lIuld4nuY5TUVERgJr5oT4+PqrokxzHied5pKamwtfXVxqTztinixcvwhacKOO07kWLFmH58uUNbnP27FmkpqZi/Pjx2LhxIx5//HEANWduIiIisHTpUjzxxBN4/PHHcfHiRXz//ffS9964cQNeXl747rvv8MADD5jdv7kzQMYD4uvrC8D5PgkBQHp6OmJiYqDRaExicaZPDbb0Sa5PDYIg1Mul0vskx3ESRdHimFRqn+Q6ToIg4Ny5c2jbtq3JmFRyn+Q6TseOHUOvXr1w5MgRdO/eXRV9kuM4GQwGpKenWzUm5exTUVERAgICUFxcLP39boisZ4DmzZuHyZMnN7hNdHQ08vLyAJjO+XF3d0d0dDRycnIA1FSAx44dM/ne/Px86TVL3N3d4e7uXq9do9FIB9qo9inVxrTX3a+t7cZTueZiNLY3Nsam7hNgOXZH98lSLpXcp6Y+Tg2NSaX2qaF2R/eJ5/lGj0ln65Mcx8l4tsKYz9vFqIQ+yXGcjIWHtWPS2fpkiawFUHBwMIKDg2+7XUJCAtzd3XHu3DncfffdAICqqipkZ2cjKioKANCnTx+8/vrruHr1KkJCQgAA+/fvh6+vr0nhRAghhBCiiDlAvr6+mDFjBpYsWYLIyEhERUVh5cqVAIB//OMfAIDBgwejQ4cOeOyxx7BixQro9Xq8+OKLSExMNHuGR8l4nkdYWJjN1S6pj3LJBuWRHcolO8YcUi4bR61jUhEFEACsXLkSbm5ueOyxx3Dz5k306tULP/30EwICAgDUnIbbvXs3nnzySfTp0wdeXl6YNGkSXn31VZkjZ4/jOPj7+8sdhipQLtmgPLJDuWTHeAnM+H9iH7WOSVknQTujkpIS+Pn5WT2JSg6CICA7Oxtt2rRRXUXe1CiXbFAe2aFcsnPixAn06NEDx48fR/fu3eUOR7GUMiZt/fvtvD0hFomiiMrKStU9l0UOlEs2KI/sUC7ZoWeBsaHWMUkFECGEEEJcDhVAhBBCCHE5VAApEM/ziIiIcOprsUpBuWSD8sgO5ZIdWgXGhlrHpGJWgZH/4ThOekwHaRzKJRuUR3Yol+zQKjA21Dom1VXOuQjjbcnr3rKc2I5yyQblkR3KJTvGHFIuG0etY5IKIIWy9am3xDLKJRuUR3Yol8TZqHFMUgFECCGEEJdDBRAhhBBCXA4VQArE8zx0Op3qZuTLgXLJBuWRHcolO7QKjA21jkl19caFuLnRAj5WKJdsUB7ZoVwSZ6PGMUkFkAIJgoCMjAxVTkprapRLNiiP7FAu2THmkHLZOGodk1QAEUIIIcTlUAFECCGEEJdDBRAhhBBCXA4VQArE8zxiY2NVNyNfDpRLNiiP7FAu2aFVYGyodUyqqzcupLq6Wu4QVINyyQblkR3KJXE2ahyTVAApkCAIyMrKUt2MfDlQLtmgPLJDuWSHVoGxodYxSQUQIYQQQlwOFUCEEEIIcTlUACmU2iajyYlyyQblkR3KJXE2ahyT6ru3tQvQaDSIi4uTOwxVoFyyQXlkh3LJjkajMfk/sY9ax6T6SjoXIIoiysrKIIqi3KEoHuWSDcojO5RLdow5pFw2jlrHJBVACiQIAi5fvqy6GflyoFyyQXlkh3LJDq0CY0OtY5IKIEIIIYS4HCqACCGEEOJyaBK0AnEcB61WC47j5A5F8SiXbFAe2aFcNuzGjRtIS0uzattz585J/7dmInR8fDw8PT0bFZ8aqXVMcqLaZjU1UklJCfz8/FBcXAxfX1+5wyGEEFJLamoqEhISHLLvlJQUdOvWzSH7Jo5n699vOgOkQKIoori4GH5+fqqryJsa5ZINyiM7lMuGxcfHIyUlxaptb968iTNnzqBDhw7w8PCwat+kPrWOSSqAFEgQBOj1evj4+ND9LRqJcskG5ZEdymXDPD09rT5LYzAY0KJFC8TGxlIuG0GtY5ImQRNCCCHE5VABRAghhBCXo5gCKD09HSNHjkRQUBB8fX1x99134+effzbZJicnB8OGDYOnpydCQkKwYMECVFdXyxSx43AcBy8vL1Vdi5UL5ZINyiM7lEt2KJdsqDWPiimAhg8fjurqavz0009ISUnBnXfeieHDh0Ov1wOoudY7bNgwVFZW4tChQ/joo4+wZcsWLF68WObI2eN5HpGRkap8OF1To1yyQXlkh3LJDuWSDbXmURHL4AsKChAcHIyDBw+iX79+AIDS0lL4+vpi//79GDRoEPbu3Yvhw4fjypUrCA0NBQBs2LABzz77LK5duwatVmvVz1LCMnhBEFBYWIjAwEDVDcimRrlkg/LIDuWSHcolG0rJo61/v523J7W0aNEC7dq1w9atW1FeXo7q6mps3LgRISEh0v0gDh8+jM6dO0vFDwAMGTIEJSUlOH36tFyhO4QoiigoKFDdg+nkQLlkg/LIDuWSHcolG2rNoyKWwXMchx9//BGjRo2Cj48PeJ5HSEgI9u3bh4CAAACAXq83KX4ASF8bL5OZU1FRgYqKCunrkpISADWX1AwGg/TzeZ6HIAgmA8BSO8/z4DjOYrtxv7XbgfoP7LPUDtQMyNr7McYiiqLJ9rbGLlefNBqNxdgd2SdzuVR6n+Q4ToDlManUPsl1nIwx1h2TSu6TnMepdi7V0qemPk7GWKwZk3L3yRayFkCLFi3C8uXLG9zm7NmzaNeuHRITExESEoLk5GR4eHjg/fffx//93//h+PHjCA8PtzuGpKQkvPLKK/XaMzMz4e3tDQDw8/NDeHg48vPzUVxcLG0TFBSEoKAg5Obmory8XGoPCwuDv78/srOzUVlZKbVHRETA29sbmZmZJgdKp9PBzc0NGRkZJjHExsaiuroaWVlZUhvP84iJiUFVVRXOnz8vDUKtVovo6GgUFxebFHxeXl6IjIxEYWEhCgoKpHZn61NcXBzKy8tx+fJlqb0p+uTj44OioiKTXCq9T3Icp6ioKFRUVJjkUel9kus4eXh44O+//zbJpdL7JOdxKiwslHKplj419XHiOM4kj87ap4sXL8IWss4BunbtGq5fv97gNtHR0UhOTsbgwYPx999/m1zXi42NxbRp07Bo0SIsXrwYu3btwsmTJ6XXs7KyEB0djdTUVHTt2tXs/s2dATIeEOPPcrZPDRzHQa/XIzg4WNrGGT812NInuT41iKKIvLw8hISESLEpvU9ynQGyNCaV2ie5jpOlMankPsl1nKqrq5Gfny/lUg19kuM4CULNjRCtGZNy9qmoqAgBAQHKeBRGcHAwgoODb7vdjRs3APwv4UbGRABAnz598Prrr+Pq1asICQkBAOzfvx++vr7o0KGDxX27u7vD3d29XrtGo6l3x8u6P9/edkt30rSlvWXLlma35TjO7PasYndknyzF7sg+cRyHVq1aWR2jre1y9Kmhdkf2ydKYVHKf5DhOrMakM/XJUoy2ttvaJzc3N7O5VHKf5DhOGo3GpjHpbH2yRBGToPv06YOAgABMmjQJf/zxB9LT07FgwQJkZWVh2LBhAIDBgwejQ4cOeOyxx/DHH3/g+++/x4svvojExESzBY6SCYKAvLw8m693kvool2xQHtmhXLJDuWRDrXlURAEUFBSEffv2oaysDAMHDkT37t3x22+/4dtvv8Wdd94JoKYK3b17NzQaDfr06YMJEyZg4sSJePXVV2WOnj3jg+nUNiNfDpRLNiiP7FAu2aFcsqHWPCpiFRgAdO/eHd9//32D20RFReG7775roogIIYQQolSKKYCairHCNS6Hd0YGgwFlZWUoKSlR1ZN55UC5ZIPyyA7lkh3KJRtKyaPx77a1Z6qoAKqjtLQUABAZGSlzJIQQQgixVWlpKfz8/G67nSIehdGUBEHAlStX4OPjIy3vdTbGpfqXLl1y2sd1KAXlkg3KIzuUS3Yol2woJY+iKKK0tBQtW7a0akUYnQGqg+d5REREyB2GVXx9fZ16MCoJ5ZINyiM7lEt2KJdsKCGP1pz5MVLEKjBCCCGEEJaoACKEEEKIy6ECSIHc3d2xZMkS1d3gUQ6USzYoj+xQLtmhXLKh1jzSJGhCCCGEuBw6A0QIIYQQl0MFECGEEEJcDhVAhBBCCHE5VAARQgghxOVQAdQEkpKS0KNHD/j4+CAkJASjRo3CuXPnTLa5desWEhMT0aJFC3h7e2PMmDHIz8832SYnJwfDhg2Dp6cnQkJCsGDBAlRXVzf4szmOA8dxOHLkiEl7RUUFWrRoAY7j8Msvv5hsv3PnTrP7+uWXX6T9cRyH4OBgPPjgg/jrr7+sT4aV5MwZAPz8888YPnw4goOD0bx5c8TExODhhx/GwYMHpW3q5sPDwwMdO3bEpk2bTPY1efJkaZtmzZohNDQU999/PzZv3gxBEMzuy9x/tY8TS2+88QY4jsPs2bNN2mlMNqyp8wa4xrjMzc3FhAkT0KJFC3h4eKBz5844ceKE9Looili8eDHCw8Ph4eGBQYMGISMjw2QfhYWFGD9+PHx9feHv749p06ahrKyswZ/bpk0bcByHL774ot5rHTt2BMdx2LJli8n2b775ptl9ZWdnm+QoMDAQ/fv3R3JysvWJsIFcOQOA33//HQ8//DDCw8Ph7u6OqKgoDB8+HP/5z3+kZ3LVzYdWq0Xbtm2xdOlSk+d2vfzyy9I2bm5uCAoKwj333IM333wTFRUVZvdl7r/ax6lBIrFZ//79xQ8//NDq7YcMGSJ++OGH4qlTp8STJ0+KDz74oNi6dWuxrKxM2mbGjBliZGSkeODAAfHEiRNi7969xb59+0qvV1dXi506dRIHDRok/v777+J3330nBgUFic8991yDPxuAGBkZKT7++OMm7Z9//rnYunVrEYD4888/m2z/zTffmN3Xzz//LAIQz507J+bl5YkpKSniwIEDxcjISLGioqLBOJSUs3fffVfkOE6cOHGieODAATE7O1v8448/xDfffFPs1q2bxXxcuHBBfOutt0Se58Uff/xR2m7SpEni0KFDxby8PPHy5ctiSkqK+Prrr4ve3t7iAw88IFZVVYkVFRViXl6e9N+4ceOk7zH+11CObc2v0bFjx8Q2bdqId9xxhzhr1iyT19Q+JkVRWXlzhXFZWFgoRkVFiZMnTxaPHj0qXrhwQfz+++/F8+fPS9u88cYbop+fn7hz507xjz/+EEeMGCHqdDrx5s2b0jZDhw4V77zzTvHIkSNicnKy2LZtW/HRRx9t8GdHRUWJkZGR4uDBg03aDx8+LAYGBopeXl4mfYmKihLXrl1rdl9ZWVkiAPHHH38U8/LyxL/++kt85JFHRF9fX1Gv1zcYh5JytnPnTlGr1YoPPvig+P3334uZmZnimTNnxPfff1+84447xL///ttsPrKzs8VPPvlEbN68ufj+++9L+1uyZInYsWNHMS8vT8zNzRX//PNPcd26dWJISIjYrVs3saSkRKyurjYZf/PmzZO+x/jfjRs3rModFUB2sPeXptHVq1dFAOKvv/4qiqIoFhUVic2aNRO/+uoraZuzZ8+KAMTDhw+LoiiK3333ncjzvMmbZ/369aKvr2+Dv4AAiC+++KLo6+trMijuv/9+8aWXXrLrj41xUIuiKO7atUsEIP7xxx8N9lkpObt48aLYrFkzcc6cOWZfFwRB+re5fIiiKMbExIgrVqyQvp40aZI4cuTIevs6cOCACED897//Xe81S99jiT35LS0tFWNjY8X9+/eL/fv3N/lD7gpjUhSVkzdXGZfPPvusePfdd1t8XRAEMSwsTFy5cqXUVlRUJLq7u4uff/65KIqieObMGRGAePz4cWmbvXv3ihzHibm5uRb3HRUVJS5atEh0d3cXc3JypPbp06eLTz/9tOjn52dzAfT7779LbX/++acIQPz2228txiCKyslZWVmZ2KJFC/Ghhx5q8GeLovl8iKIo3nfffeJTTz0lfb1kyRLxzjvvrLefs2fPilqtVnzhhRfqvWbpe6xBl8BkUFxcDAAIDAwEAKSkpKCqqgqDBg2StomPj0fr1q1x+PBhAMDhw4fRuXNnhIaGStsMGTIEJSUlOH36dIM/LyEhAW3atMHXX38NoOb0+8GDB/HYY481uh/G08VarbZR+7LmZwGOz9nXX3+NqqoqLFy40OzrDT0gVxRF7Nu3Dzk5OejVq9dt+zRw4EDceeed2LFjx223dYTExEQMGzbMJIdGNCYtkyNvrjIud+3ahe7du+Mf//gHQkJC0LVrV/z73/+WXs/KyoJerzfJr5+fH3r16mWSX39/f3Tv3l3aZtCgQeB5HkePHm3w54eGhmLIkCH46KOPAAA3btzAtm3bMHXq1Eb16+bNm9i6dSsA9uNSrpz98MMPuH79usUxCTQ8Lk+cOIGUlBSrxmR8fDweeOAB5mOSCiArLFu2DN7e3tJ/ycnJmDFjhklbTk6OVfsSBAGzZ8/GXXfdhU6dOgEA9Ho9tFot/P39TbYNDQ2FXq+Xtqn9C9P4uvG125k6dSo2b94MANiyZQsefPBBBAcHWxVzXREREfD29oa/vz8+++wzjBgxAvHx8SbbKDVn6enp8PX1RVhYmNT29ddfm8Rdd36JMR9arRbDhg3DkiVLcM8991jVt/j4eGRnZ1u1bW2Nze8XX3yB1NRUJCUlmX1djWMSUG7eXGVcXrhwAevXr0dsbCy+//57PPnkk3jmmWekgsSYH3P5q53fkJAQk9fd3NwQGBho9bjcsmULRFHE9u3bERMTgy5dutiSBknfvn3h7e0NLy8vrFq1CgkJCbjvvvtMtlFqztLT0wEA7dq1k9qOHz9uEvfu3bvN5kOr1aJHjx4YN24cJk6caLFvtdk7JhtCT4O3wowZMzBu3Djp6/Hjx2PMmDEYPXq01NayZUur9pWYmIhTp07ht99+Yx5nQyZMmIBFixbhwoUL2LJlC9atW2f3vpKTk+Hp6YkjR45g2bJl2LBhQ71tlJyzup9ahgwZgpMnTyI3NxcDBgyAwWAweT05ORk+Pj6oqKjAsWPHMHPmTAQGBuLJJ5+87c8SRbHBT0mWNCa/ly5dwqxZs7B//340b97c5p/NSlOPSUDZeVP7uARqPux0794dy5YtAwB07doVp06dwoYNGzBp0iSb47HHsGHD8MQTT+DgwYPYvHlzo87+bNu2DfHx8Th16hQWLlyILVu2oFmzZibbqCFnRnfccQdOnjwJAIiNja03sX/btm1o3749qqqqcOrUKTz99NMICAjAG2+8cdt92zsmG0IFkBUCAwOlSy8A4OHhgZCQELRt29am/cycORO7d+/GwYMHERERIbWHhYWhsrISRUVFJp8c8/PzpU98YWFhOHbsmMn+jCtLan8qtKRFixYYPnw4pk2bhlu3buGBBx5AaWmpTfEb6XQ6+Pv7o127drh69Wq9VSiAcnMWGxuL4uJi6PV6aRtvb2+0bdsWbm7m3y7GfAA1q0WOHj2K119/3ao/NGfPnoVOp7vtdnU1Jr8pKSm4evUqunXrJrUZDAYcPHgQ77zzDioqKlQ5JgHl5s0VxiUAhIeHo0OHDiZt7du3ly6VGvuen5+P8PBwaZv8/HzpLE1YWBiuXr1qso/q6moUFhZaNS7d3Nzw2GOPYcmSJTh69Ci++eYbq2I3JzIyErGxsVIx8NBDD+HUqVMmz9RSas5iY2MBAOfOnUPv3r0B1DwzrKG4IyMjpdfbt2+PzMxMvPTSS3j55Zdv+6HC3jHZELoE1gREUcTMmTPxzTff4Keffqp3EBMSEtCsWTMcOHBAajt37hxycnLQp08fAECfPn3w119/mQzS/fv3w9fXt97gt2Tq1Kn45ZdfMHHiRGg0GgY9+9/Zmcb8kjBHrpyNHTsWzZo1w/Lly+2OXaPR4ObNm7fd7qeffsJff/2FMWPG2P2z7HHffffhr7/+wsmTJ6X/unfvjvHjx+PkyZPQaDQ0Js2QM2+uMC4B4K677qp3u4v09HRERUUBqCnqwsLCTPJbUlKCo0ePmuS3qKgIKSkp0jY//fQTBEGwar4JUDMuf/31V4wcORIBAQGN7RaAmmPo5uaG9957j8n+jOTK2eDBgxEYGNjoMVldXY3KysoGt0tLS8O+ffuYj0k6A2SFsrIyk/shGCdZ1r42GhwcbPEXeGJiIj777DN8++238PHxkb7Pz88PHh4e8PPzw7Rp0zB37lwEBgbC19cXTz/9NPr06SNV1oMHD0aHDh3w2GOPYcWKFdDr9XjxxReRmJho9RN6hw4dimvXrsHX17fB7bKysqTTmEbGar8uT09PTJ8+HUuWLMGoUaOkU5RKzVnr1q2xevVqzJo1C4WFhZg8eTJ0Oh0KCwvxySefAEC9mK9evYpbt25Jlxo+/vhjjB071mSbiooK6PV6GAwG5OfnY9++fUhKSsLw4cOtvgZeW2Py6+PjI82lMvLy8kKLFi2kdjWOSUC5eXOFcQkAc+bMQd++fbFs2TKMGzcOx44dw6ZNm6R7GBnvu7R06VLExsZCp9PhpZdeQsuWLTFq1CgANWcWhg4diunTp2PDhg2oqqrCzJkz8cgjj1h92b19+/YoKCiAp6dng9vl5ubWG5fGwqMujuPwzDPP4OWXX8YTTzwh7VupOfP29sb777+Phx9+GMOGDcMzzzyD2NhYlJWVYd++fQDqj8nr169Dr9ejuroaf/31F9566y3ce++9Ju//6upq6PV6CIKA69ev45dffsHSpUvRpUsXLFiwwGwsdrNr7ZiLWbJkiQigwf+ysrIsfr+l76m91PHmzZviU089JQYEBIienp7iQw89JObl5ZnsJzs7W3zggQdEDw8PMSgoSJw3b55YVVXVYOxoYAnx33//bXbJsbn/kpOTLS6vzcnJEd3c3MRt27apImeiKIr79+8XH3jgATEwMFB0c3MTQ0NDxVGjRon79u2TtjHmw/ifm5ubqNPpxPnz55vcr2jSpEkm2wQHB4uDBg0SN2/eLBoMBrM//3bLjRub37rqLucWRfWNSVFUdt5E0TXG5X/+8x+xU6dOoru7uxgfHy9u2rTJ5HVBEMSXXnpJDA0NFd3d3cX77rtPPHfunMk2169fFx999FHR29tb9PX1FadMmSKWlpY2+HMbWtYuiqLZZfDm+vfxxx9bXPZdXl4uBgQEiMuXL1dFzkRRFI8fPy6OHTtWDAkJEd3c3MQWLVqIQ4YMEb/44ot6y+CN/2k0GjEiIkKcPn26ePXqVbO50Gg0YmBgoHj33XeLa9euFW/dumX25zdmGTwnirVuw0gIIYQQ4gJoDhAhhBBCXA4VQIQQQghxOVQAEUIIIcTlUAFECCGEEJdDBRAhhBBCXA4VQIQQQghxOVQAEUIIIcTlUAFECCGEEJdDBRAhhBBCXA4VQIQQQghxOVQAEUIIIcTlUAFECCGEEJfz/wCIlFQ0Hnco1AAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Метки осей (4 критерия)\n",
        "labels = ['\\u00B1 200 \\u2033', '\\u00B1 400 \\u2033', '\\u00B1 600 \\u2033', 'c\\u209c\\u2033']\n",
        "\n",
        "# Три ряда данных\n",
        "values1 = [2.6, 7.8, 23, 3]   # ВИМ МЛР\n",
        "values2 = [1, 5, 10, 1]   # Nivel 220\n",
        "values3 = [4.8, 3, 11, 3]    # ВИМ GBDT\n",
        "values4 = [2.6, 3, 11, 3]    # Гибрид ВИМ+GBDT\n",
        "\n",
        "# Углы\n",
        "angles = np.linspace(0, 2 * np.pi, len(labels), endpoint=False).tolist()\n",
        "angles_closed = angles + angles[:1]\n",
        "v1 = values1 + values1[:1]\n",
        "v2 = values2 + values2[:1]\n",
        "v3 = values3 + values3[:1]\n",
        "v4 = values4 + values4[:1]\n",
        "\n",
        "# Построение\n",
        "fig, ax = plt.subplots(figsize=(6.5, 6.5), subplot_kw=dict(polar=True))\n",
        "\n",
        "# Ряд 1 — ВИМ\n",
        "ax.plot(angles_closed, v1, 'o-', linewidth=2, label='ВИМ МЛР', color='tab:blue')\n",
        "ax.fill(angles_closed, v1, alpha=0.2, color='tab:blue')\n",
        "\n",
        "# Ряд 2 — Nivel 220\n",
        "ax.plot(angles_closed, v2, 's--', linewidth=2, label='Nivel 220', color='tab:orange')\n",
        "ax.fill(angles_closed, v2, alpha=0.15, color='tab:orange')\n",
        "\n",
        "# Ряд 3 — ВИМ GBDT\n",
        "ax.plot(angles_closed, v3, 'd-.', linewidth=2, label='ВИМ GBDT', color='tab:green')\n",
        "ax.fill(angles_closed, v3, alpha=0.1, color='tab:green')\n",
        "\n",
        "# Ряд 4 — ВИМ GBDT+МЛР гибрид\n",
        "ax.plot(angles_closed, v4, 'd-.', linewidth=4, label='ВИМ GBDT+МЛР', color='tab:red')\n",
        "ax.fill(angles_closed, v4, alpha=0.1, color='tab:red')\n",
        "\n",
        "# --- ДОБАВЛЕНО: радиальная сетка («линейка») ---\n",
        "ax.grid(True, linestyle='--', alpha=0.6)\n",
        "ax.set_ylim(0, 25)\n",
        "\n",
        "# Деления по радиусу (например, каждые 2 единицы)\n",
        "ax.set_yticks([2, 5, 10, 20, 25])\n",
        "ax.set_yticklabels([f'{y}″' for y in [2, 5, 10, 20, 30]], fontsize=14)\n",
        "\n",
        "# Оси (метки критериев)\n",
        "ax.set_xticks(angles)\n",
        "ax.set_xticklabels(labels, fontsize=14)\n",
        "\n",
        "# Легенда\n",
        "ax.legend(loc='upper right', bbox_to_anchor=(1.2, 1.05))\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 568
        },
        "id": "oZsi0ZNjXBcX",
        "outputId": "02ce62ee-01d8-4b6a-a075-a757832bba77"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 650x650 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N6S3YKLMxYoY"
      },
      "source": [
        "# Калибровка видеоинклинометра при помощи GBDT"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IMCPLOIqpfK_",
        "outputId": "9c8969ea-b806-4e48-bc2f-ed06a52e6d23"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "✅ Обработан: 2025_10_24 15_05_59.csv\n",
            "✅ Обработан: 2025_10_30 15_54_39.csv\n"
          ]
        }
      ],
      "source": [
        "# Выбор диапазона  исследования в угловых секундах (для анализа) : '0-200', '200-400', '400-600'\n",
        "#Для каждого диапазона должна быть своя модель (свой набор признаков)\n",
        "#Расширить набор признаков можно через функцию \"extract_features_selected\"\n",
        "range_ex='400-600'\n",
        "combined_df_test, combined_df =download_exp_data_end_transform(range_ex)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZaTRz3EpB6Zq"
      },
      "outputs": [],
      "source": [
        "df_calib = combined_df.copy()\n",
        "\n",
        "# Формирование массива калибровочного сеанса\n",
        "df_calib['vim_points_x'] = df_calib['vim_points_x'].apply(parse_points)\n",
        "df_calib['vim_points_y'] = df_calib['vim_points_y'].apply(parse_points)\n",
        "df_calib['vim_points_brig'] = df_calib['vim_points_brig'].apply(parse_points)\n",
        "df_calib['nivel_y'] = df_calib['nivel_y'].apply(safe_float_conversion)/0.0047 #перевод в секунды\n",
        "df_calib = pd.concat([df_calib.reset_index(), (extract_features_selected(df_calib)).reset_index()], axis=1)\n",
        "\n",
        "# Формирование массива тестового сеанса\n",
        "df_test=combined_df_test.copy()\n",
        "df_test['vim_points_x'] = df_test['vim_points_x'].apply(parse_points)\n",
        "df_test['vim_points_y'] = df_test['vim_points_y'].apply(parse_points)\n",
        "df_test['vim_points_brig'] = df_test['vim_points_brig'].apply(parse_points)\n",
        "df_test['nivel_y'] = df_test['nivel_y'].apply(safe_float_conversion)/0.0047 #перевод в секунды\n",
        "df_test = pd.concat([df_test.reset_index(), (extract_features_selected(df_test)).reset_index()], axis=1)\n",
        "\n",
        "df_calib.to_csv('CALIB.csv')\n",
        "df_test.to_csv('TEST.csv')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%capture\n",
        "!pip install catboost optuna"
      ],
      "metadata": {
        "id": "Egxq71P2V46D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import StandardScaler, MinMaxScaler\n",
        "from sklearn.metrics import mean_squared_error, r2_score\n",
        "from catboost import CatBoostRegressor, Pool, cv\n",
        "import optuna\n",
        "import warnings\n",
        "from sklearn.model_selection import KFold\n",
        "import math\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from statsmodels.stats.outliers_influence import variance_inflation_factor\n",
        "\n",
        "import gc # garbage collector\n",
        "from sklearn.metrics import mean_absolute_error\n",
        "\n",
        "import joblib\n",
        "import os\n",
        "\n",
        "from scipy.spatial.distance import cdist\n",
        "warnings.filterwarnings(\"ignore\")"
      ],
      "metadata": {
        "id": "2SFIbjq4Uuk1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class CFG:\n",
        "    TARGET = ['nivel_y']\n",
        "    N_FOLDS = 5\n",
        "    RANDOM_STATE = 3\n",
        "    TEST_SIZE = 0.2\n",
        "    VAL_SIZE = 0.2\n",
        "    PATH_TRAIN = '/content/CALIB.csv'\n",
        "    PATH_TEST = '/content/TEST.csv'\n",
        "\n",
        "    TARGET_SCALER = None  # 'standard', 'minmax', 'log'"
      ],
      "metadata": {
        "id": "6Nd_fS9kU0Wh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "from sklearn.preprocessing import StandardScaler, MinMaxScaler\n",
        "from typing import Tuple, List\n",
        "\n",
        "class DataLoader:\n",
        "    def __init__(self, df: pd.DataFrame, target_cols: List[str] = ['nivel_y']):\n",
        "        self.df = df.copy()\n",
        "        self.target_cols = target_cols\n",
        "        self.X = None\n",
        "        self.y = None\n",
        "        self.feature_names_ = []\n",
        "        self.feature_scaler = StandardScaler()\n",
        "        self.target_scaler = None\n",
        "\n",
        "    @staticmethod\n",
        "    def reduce_mem_usage(dataframe: pd.DataFrame) -> pd.DataFrame:\n",
        "        \"\"\"Оптимизация памяти с пропуском временных и категориальных колонок.\"\"\"\n",
        "        start_mem = dataframe.memory_usage().sum() / 1024**2\n",
        "        print(f\"Изначальное использование памяти: {start_mem:.2f} MB\")\n",
        "\n",
        "        for col in dataframe.columns:\n",
        "            col_type = dataframe[col].dtype\n",
        "            if str(col_type).startswith('datetime') or str(col_type) == 'category':\n",
        "                continue\n",
        "\n",
        "            if col_type != object:\n",
        "                c_min = dataframe[col].min()\n",
        "                c_max = dataframe[col].max()\n",
        "                if str(col_type)[:3] == 'int':\n",
        "                    if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:\n",
        "                        dataframe[col] = dataframe[col].astype(np.int8)\n",
        "                    elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:\n",
        "                        dataframe[col] = dataframe[col].astype(np.int16)\n",
        "                    elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:\n",
        "                        dataframe[col] = dataframe[col].astype(np.int32)\n",
        "                else:\n",
        "                    if c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:\n",
        "                        dataframe[col] = dataframe[col].astype(np.float32)\n",
        "                    else:\n",
        "                        dataframe[col] = dataframe[col].astype(np.float64)\n",
        "            else:\n",
        "                dataframe[col] = dataframe[col].astype('category')\n",
        "\n",
        "        end_mem = dataframe.memory_usage().sum() / 1024**2\n",
        "        print(f\"Итоговое использование памяти: {end_mem:.2f} MB \"\n",
        "              f\"(экономия {(start_mem - end_mem) / start_mem * 100:.1f}%)\")\n",
        "        return dataframe\n",
        "\n",
        "    def _detect_time_series_cols(self) -> pd.DataFrame:\n",
        "        \"\"\"Автоматически определяет временные ряды как все числовые столбцы до мета-признаков.\"\"\"\n",
        "        meta_candidates = self.df.columns[-30:]  # расширенный буфер\n",
        "        meta_numeric = self.df[meta_candidates].select_dtypes(include=[np.number]).columns\n",
        "        known_meta = { 'time', 'center_vim_bubble_X', 'center_vim_bubble_Y',\n",
        "            'method_vim', 'watch_indicator', 'nivel_x', 'nivel_y', 'nivel_t',\n",
        "            'temperature', 'laser_x', 'laser_y', 'method_laser', 'state_leds',\n",
        "            'Comment', 'source_file', 'brig_mean', 'centroid_x_brig',\n",
        "            'centroid_y_brig', 'centroid_x', 'centroid_y', 'form_factor',\n",
        "            'aspect_ratio', 'point_density', 'circularity',\n",
        "            'bounding_box_diagonal', 'orientation_angle', 'n_points', 'brig_skew'\n",
        "        }\n",
        "        meta_cols = [c for c in self.df.columns if c in known_meta or c in meta_numeric]\n",
        "        ts_cols = [c for c in self.df.columns if c not in meta_cols and pd.api.types.is_numeric_dtype(self.df[c])]\n",
        "        return self.df[ts_cols]\n",
        "\n",
        "    def _engineer_time_series_features(self, ts_df: pd.DataFrame) -> pd.DataFrame:\n",
        "        \"\"\"Генерация признаков из временных рядов с интерполяцией пропусков.\"\"\"\n",
        "        features = pd.DataFrame(index=ts_df.index)\n",
        "\n",
        "        # === Интерполяция пропусков по строкам ===\n",
        "        # 1. Интерполируем линейно внутри каждой строки\n",
        "        # ts_df_interp = ts_df.apply(lambda row: row.interpolate(method='linear'), axis=1)\n",
        "\n",
        "        # # 2. Заполняем оставшиеся NaN на краях (если начало или конец — NaN)\n",
        "        # ts_df_interp = ts_df_interp.apply(lambda row: row.fillna(method='bfill').fillna(method='ffill'), axis=1)\n",
        "\n",
        "        # 3. Если вся строка была NaN — заполняем нулями (крайне редкий случай)\n",
        "        ts_df_interp = ts_df.fillna(0.0)\n",
        "\n",
        "        # # === Генерация признаков ===\n",
        "        features['ts_mean'] = ts_df_interp.mean(axis=1)\n",
        "        features['ts_std'] = ts_df_interp.std(axis=1)\n",
        "        features['ts_min'] = ts_df_interp.min(axis=1)\n",
        "        features['ts_max'] = ts_df_interp.max(axis=1)\n",
        "        features['ts_range'] = features['ts_max'] - features['ts_min']\n",
        "        features['ts_skew'] = ts_df_interp.skew(axis=1)\n",
        "        features['ts_kurt'] = ts_df_interp.kurtosis(axis=1)\n",
        "        features['ts_last'] = ts_df_interp.iloc[:, -1]\n",
        "        features['ts_first'] = ts_df_interp.iloc[:, 0]\n",
        "        features['ts_diff'] = features['ts_last'] - features['ts_first']\n",
        "        features['ts_nonzero_ratio'] = (ts_df_interp != 0).mean(axis=1)\n",
        "\n",
        "        window = min(10, ts_df_interp.shape[1])\n",
        "        features['ts_rolling_mean'] = ts_df_interp.iloc[:, -window:].mean(axis=1)\n",
        "        features['ts_rolling_std'] = ts_df_interp.iloc[:, -window:].std(axis=1)\n",
        "\n",
        "        return features\n",
        "\n",
        "    def _extract_meta_features(self) -> pd.DataFrame:\n",
        "        \"\"\"Извлекает известные мета-признаки, пропуская нечисловые и таргет.\"\"\"\n",
        "        all_meta_cols = [\n",
        "            'center_vim_bubble_X', 'center_vim_bubble_Y',\n",
        "            'nivel_x', 'nivel_t',\n",
        "            'temperature',\n",
        "            'laser_x', 'laser_y',\n",
        "            'brig_mean', 'centroid_x_brig', 'centroid_y_brig',\n",
        "            'centroid_x', 'centroid_y',\n",
        "            'form_factor', 'aspect_ratio', 'point_density',\n",
        "            'circularity', 'bounding_box_diagonal',\n",
        "            'orientation_angle', 'n_points', 'brig_skew'\n",
        "        ]\n",
        "        # Фильтруем существующие и числовые\n",
        "        meta_cols = [c for c in all_meta_cols if c in self.df.columns and pd.api.types.is_numeric_dtype(self.df[c])]\n",
        "        return self.df[meta_cols].fillna(0)\n",
        "\n",
        "    def load(\n",
        "        self,\n",
        "        target_scaler_type: str = None,\n",
        "        drop_columns: List[str] = None\n",
        "    ) -> Tuple[pd.DataFrame, pd.Series]:\n",
        "        \"\"\"\n",
        "        Загрузка и обработка данных.\n",
        "\n",
        "        Parameters:\n",
        "        - target_scaler_type: тип масштабирования целевой переменной ('standard', 'minmax', 'log', None)\n",
        "        - drop_columns: список колонок, которые нужно исключить из исходного df перед обработкой\n",
        "        \"\"\"\n",
        "        print(\" → Загрузка и обработка данных...\")\n",
        "\n",
        "        # 0. Удаление указанных колонок\n",
        "        if drop_columns:\n",
        "            existing_to_drop = [col for col in drop_columns if col in self.df.columns]\n",
        "            if existing_to_drop:\n",
        "                print(f\" → Удаление колонок: {existing_to_drop}\")\n",
        "                self.df = self.df.drop(columns=existing_to_drop)\n",
        "            else:\n",
        "                print(\" → Нет колонок для удаления (указаны несуществующие).\")\n",
        "\n",
        "        # 1. Оптимизация памяти\n",
        "        self.df = self.reduce_mem_usage(self.df)\n",
        "\n",
        "        # 2. Извлечение y\n",
        "        if len(self.target_cols) == 1:\n",
        "            self.y = self.df[self.target_cols[0]].astype(np.float32)\n",
        "        else:\n",
        "            self.y = self.df[self.target_cols].astype(np.float32)\n",
        "\n",
        "        # 3. Извлечение признаков\n",
        "        ts_df = self._detect_time_series_cols()\n",
        "        ts_features = self._engineer_time_series_features(ts_df)\n",
        "        meta_features = self._extract_meta_features()\n",
        "\n",
        "        self.X = pd.concat([ts_features, meta_features], axis=1)\n",
        "        self.feature_names_ = self.X.columns.tolist()\n",
        "\n",
        "        # 4. Масштабирование X\n",
        "        self.X = pd.DataFrame(\n",
        "            self.feature_scaler.fit_transform(self.X),\n",
        "            columns=self.feature_names_,\n",
        "            index=self.X.index\n",
        "        )\n",
        "\n",
        "        # 5. Масштабирование y (опционально)\n",
        "        if target_scaler_type == 'standard':\n",
        "            self.target_scaler = StandardScaler()\n",
        "        elif target_scaler_type == 'minmax':\n",
        "            self.target_scaler = MinMaxScaler()\n",
        "        elif target_scaler_type == 'log':\n",
        "            self.target_scaler = None\n",
        "            if (self.y <= 0).any():\n",
        "                print(\"Отрицательные значения — log-масштабирование невозможно\")\n",
        "            else:\n",
        "                self.y = np.log1p(self.y)\n",
        "        else:\n",
        "            self.target_scaler = None\n",
        "\n",
        "        if self.target_scaler is not None:\n",
        "            if len(self.target_cols) == 1:\n",
        "                self.y = pd.Series(\n",
        "                    self.target_scaler.fit_transform(self.y.values.reshape(-1, 1)).flatten(),\n",
        "                    index=self.y.index,\n",
        "                    name=self.y.name\n",
        "                )\n",
        "            else:\n",
        "                self.y = pd.DataFrame(\n",
        "                    self.target_scaler.fit_transform(self.y),\n",
        "                    columns=self.y.columns,\n",
        "                    index=self.y.index\n",
        "                )\n",
        "\n",
        "        print(f\" → Целевая переменная: min={self.y.min():.3f}, max={self.y.max():.3f}\")\n",
        "        print(f\" → Форма X: {self.X.shape}, форма y: {self.y.shape}\")\n",
        "        print(f\" → Признаки ({len(self.feature_names_)}): {self.feature_names_[:10]}...\")\n",
        "\n",
        "        return self.X, self.y"
      ],
      "metadata": {
        "id": "Ea1WmvbjU2qK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import ast\n",
        "\n",
        "def expand_array_column(df, col_name, prefix):\n",
        "    def safe_literal_eval(x):\n",
        "        if pd.isna(x) or not isinstance(x, str):\n",
        "            return []\n",
        "        try:\n",
        "            return ast.literal_eval(x)\n",
        "        except:\n",
        "            return []\n",
        "\n",
        "    arrays = df[col_name].apply(safe_literal_eval)\n",
        "    max_len = arrays.apply(len).max()\n",
        "\n",
        "    # Приведение всех массивов к одинаковой длине (заполнение NaN)\n",
        "    padded = arrays.apply(lambda arr: arr + [np.nan] * (max_len - len(arr)))\n",
        "    expanded = pd.DataFrame(padded.tolist(), index=df.index)\n",
        "\n",
        "    # Имена новых колонок\n",
        "    expanded.columns = [f\"{prefix}_{i}\" for i in range(expanded.shape[1])]\n",
        "\n",
        "    return expanded"
      ],
      "metadata": {
        "id": "CIH5iL6lbTwk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def preprocess_raw_csv(path):\n",
        "    df = pd.read_csv(path, skipinitialspace=True, index_col='index', on_bad_lines='skip')\n",
        "\n",
        "    df = df.dropna(subset=CFG.TARGET)\n",
        "\n",
        "    if 'vim_points_brig' in df.columns:\n",
        "        vim_ts = expand_array_column(df, 'vim_points_brig', 'vim')\n",
        "        df = df.drop(columns=['vim_points_brig']).join(vim_ts)\n",
        "\n",
        "    if 'laser_points_brig' in df.columns:\n",
        "        laser_ts = expand_array_column(df, 'laser_points_brig', 'laser')\n",
        "        df = df.drop(columns=['laser_points_brig']).join(laser_ts)\n",
        "\n",
        "    return df"
      ],
      "metadata": {
        "id": "QULCpQrVmTiO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_df = preprocess_raw_csv(CFG.PATH_TRAIN)\n",
        "test_df = preprocess_raw_csv(CFG.PATH_TEST)\n",
        "\n",
        "nivel_conversion = 0.0047\n",
        "vim_conversion = 0.0015 / nivel_conversion\n",
        "\n",
        "\n",
        "vim_columns = [\n",
        "    'center_vim_bubble_X',\n",
        "    'center_vim_bubble_Y',\n",
        "    'centroid_x',\n",
        "    'centroid_y',\n",
        "]\n",
        "\n",
        "# Применяем конверсию только к существующим колонкам\n",
        "for col in vim_columns:\n",
        "    if col in train_df.columns:\n",
        "        train_df[col] = train_df[col] / vim_conversion\n",
        "    if col in test_df.columns:\n",
        "        test_df[col] = test_df[col] / vim_conversion\n",
        "\n",
        "\n",
        "train_loader = DataLoader(df=train_df, target_cols=CFG.TARGET)\n",
        "X_train, y_train = train_loader.load(target_scaler_type=CFG.TARGET_SCALER\n",
        "                                     )\n",
        "\n",
        "test_loader = DataLoader(df=test_df, target_cols=CFG.TARGET)\n",
        "X_test, y_test = test_loader.load(target_scaler_type=CFG.TARGET_SCALER\n",
        "                                  )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JT2PRMuSmUQd",
        "outputId": "22c201c1-0abb-4aaf-975a-953eb19ef055"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            " → Загрузка и обработка данных...\n",
            "Изначальное использование памяти: 6.96 MB\n",
            "Итоговое использование памяти: 3.54 MB (экономия 49.2%)\n",
            " → Целевая переменная: min=123.404, max=340.426\n",
            " → Форма X: (399, 33), форма y: (399,)\n",
            " → Признаки (33): ['ts_mean', 'ts_std', 'ts_min', 'ts_max', 'ts_range', 'ts_skew', 'ts_kurt', 'ts_last', 'ts_first', 'ts_diff']...\n",
            " → Загрузка и обработка данных...\n",
            "Изначальное использование памяти: 7.96 MB\n",
            "Итоговое использование памяти: 4.02 MB (экономия 49.6%)\n",
            " → Целевая переменная: min=129.787, max=348.936\n",
            " → Форма X: (394, 33), форма y: (394,)\n",
            " → Признаки (33): ['ts_mean', 'ts_std', 'ts_min', 'ts_max', 'ts_range', 'ts_skew', 'ts_kurt', 'ts_last', 'ts_first', 'ts_diff']...\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Применение модели"
      ],
      "metadata": {
        "id": "3IC-2ELUVbHB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "if range_ex == '0-200': model_path = '/content/dbz8h/osfstorage/Ranges 0-600/catboost processing/best_catboost_model_0200.pkl'\n",
        "if range_ex == '200-400': model_path = '/content/dbz8h/osfstorage/Ranges 0-600/catboost processing/best_catboost_model_200400.pkl'\n",
        "if range_ex == '400-600': model_path = '/content/dbz8h/osfstorage/Ranges 0-600/catboost processing/best_catboost_model_400600.pkl'\n",
        "# 2. Загрузка модели\n",
        "def load_and_predict(model_path, X_data):\n",
        "    \"\"\"Загрузка модели и предсказание\"\"\"\n",
        "    loaded_model = joblib.load(model_path)\n",
        "    predictions = loaded_model.predict(X_data)\n",
        "    return predictions, loaded_model\n",
        "\n",
        "# Проверка загрузки модели\n",
        "test_predictions, loaded_model = load_and_predict(model_path, X_test)\n",
        "print(f\"Проверка загрузки модели - RMSE: {np.sqrt(mean_squared_error(y_test, test_predictions)):.4f}\")\n",
        "y_pred = loaded_model.predict(X_test)\n",
        "mean = np.mean(y_test - y_pred)\n",
        "mae = mean_absolute_error(y_test, test_predictions)\n",
        "std_err = np.std(test_predictions)\n",
        "rmse = np.sqrt(mean_squared_error(y_test, test_predictions))\n",
        "r2 = r2_score(y_test, test_predictions)\n",
        "\n",
        "\n",
        "iqr=scipy.stats.iqr(y_test - y_pred)\n",
        "median=np.median(y_test - y_pred)\n",
        "\n",
        "diff_600_GBDT=y_test - y_pred\n",
        "print(f\"\\n=== FINAL RESULTS ===\")\n",
        "print(f\"Test MEAN: {mean:.4f}\")\n",
        "print(f\"Test MAE:  {mae:.4f}\")\n",
        "print(f\"Test RMSE: {rmse:.4f}\")\n",
        "print(f\"Test R²:   {r2:.4f}\")\n",
        "print(f\"Медиана:   {median:.6f}\")\n",
        "print(f\"iqr/2²:    {iqr/2:.4f}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9_J-kHXMVdHi",
        "outputId": "b7ed6324-98a4-41fe-98d5-9101cc26edb4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Проверка загрузки модели - RMSE: 14.4380\n",
            "\n",
            "=== FINAL RESULTS ===\n",
            "Test MEAN: 1.6554\n",
            "Test MAE:  11.5673\n",
            "Test RMSE: 14.4380\n",
            "Test R²:   0.9496\n",
            "Медиана:   0.696975\n",
            "iqr/2²:    10.8531\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from scipy import stats\n",
        "\n",
        "\n",
        "# 1. Вычисляем ошибки\n",
        "errors = y_test.values - y_pred\n",
        "\n",
        "# 2. Тест Шапиро–Уилка\n",
        "# Внимание: тест не рекомендуется для n > 5000 (ограничение реализации)\n",
        "n = len(errors)\n",
        "alpha = 0.05\n",
        "\n",
        "if n < 3:\n",
        "    print(\"Слишком мало данных для теста Шапиро–Уилка\")\n",
        "elif n > 5000:\n",
        "    print(f\"Внимание: n = {n} > 5000. Тест Шапиро–Уилка может быть ненадёжным.\")\n",
        "    # Можно использовать альтернативу, например, тест D’Agostino (omnibus)\n",
        "    stat, p = stats.normaltest(errors)\n",
        "    test_name = \"D’Agostino’s K²\"\n",
        "else:\n",
        "    stat, p = stats.shapiro(errors)\n",
        "    test_name = \"Shapiro–Wilk\"\n",
        "\n",
        "print(f\"\\n=== Тест нормальности ошибок ===\")\n",
        "print(f\"Тест: {test_name}\")\n",
        "print(f\"Статистика: {stat:.4f}\")\n",
        "print(f\"p-value: {p}\")\n",
        "if p > alpha:\n",
        "    print(\"→ Ошибки неотличимы от нормального распределения (не отвергаем H₀)\")\n",
        "else:\n",
        "    print(\"→ Ошибки значимо отличаются от нормального распределения (отвергаем H₀)\")\n",
        "\n",
        "# 3. Визуализация\n",
        "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n",
        "\n",
        "# Гистограмма + KDE\n",
        "sns.histplot(errors, kde=True, bins=30, color='steelblue', ax=axes[0])\n",
        "axes[0].set_title('Распределение ошибок (остатков)')\n",
        "axes[0].set_xlabel('Ошибка (истина - прогноз)')\n",
        "axes[0].set_ylabel('Частота')\n",
        "\n",
        "# Q-Q plot\n",
        "stats.probplot(errors, dist=\"norm\", plot=axes[1])\n",
        "axes[1].set_title('Q-Q Plot ошибок')\n",
        "axes[1].get_lines()[0].set_markerfacecolor('steelblue')\n",
        "axes[1].get_lines()[0].set_markersize(4)\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 486
        },
        "id": "o_BrbJVzW6Bd",
        "outputId": "e2d46f53-2603-49f3-f993-309c7bbe42f8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "=== Тест нормальности ошибок ===\n",
            "Тест: Shapiro–Wilk\n",
            "Статистика: 0.9005\n",
            "p-value: 5.427978708279052e-13\n",
            "→ Ошибки значимо отличаются от нормального распределения (отвергаем H₀)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1400x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Скрипт получения калибровочной модели с помошью CatBoost"
      ],
      "metadata": {
        "id": "c3FpmaPOW9J4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def objective(trial):\n",
        "    params = {\n",
        "        'iterations': trial.suggest_int('iterations', 1000, 10000),\n",
        "        'learning_rate': trial.suggest_float('learning_rate', 1e-4, 1e-1, log=True),\n",
        "        'depth': trial.suggest_int('depth', 3, 10),\n",
        "        'l2_leaf_reg': trial.suggest_float('l2_leaf_reg', 1, 10),\n",
        "        'random_strength': trial.suggest_float('random_strength', 0.01, 0.5),\n",
        "        'loss_function': 'RMSE',\n",
        "        'eval_metric': 'RMSE',\n",
        "        'verbose': False,\n",
        "        'random_state': CFG.RANDOM_STATE,\n",
        "        'task_type': 'GPU' if hasattr(CatBoostRegressor(), 'get_param') else 'CPU'\n",
        "    }\n",
        "\n",
        "    X_tr, X_val, y_tr, y_val = train_test_split(\n",
        "        X_train, y_train, test_size=0.3, random_state=CFG.RANDOM_STATE\n",
        "    )\n",
        "\n",
        "    model = CatBoostRegressor(**params)\n",
        "    model.fit(Pool(X_tr, y_tr), eval_set=Pool(X_val, y_val), early_stopping_rounds=50, verbose=False)\n",
        "\n",
        "    return model.get_best_score()['validation']['RMSE']\n"
      ],
      "metadata": {
        "id": "x3ge_RFhWsk6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "study = optuna.create_study(direction='minimize')\n",
        "study.optimize(objective, n_trials=10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 723
        },
        "id": "Z6XbnGTEXMar",
        "outputId": "a3201dfd-e9d4-4cb6-d3b7-ed6319dbcdcf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[I 2025-11-29 12:02:20,382] A new study created in memory with name: no-name-79387f07-dd9c-4fd2-b520-c6fa41113bf0\n",
            "[W 2025-11-29 12:02:20,395] Trial 0 failed with parameters: {'iterations': 9854, 'learning_rate': 0.002071729834219511, 'depth': 3, 'l2_leaf_reg': 1.6905042094651987, 'random_strength': 0.02992683694461784} because of the following error: CatBoostError('catboost/cuda/cuda_lib/cuda_base.h:281: CUDA error 35: CUDA driver version is insufficient for CUDA runtime version').\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.12/dist-packages/optuna/study/_optimize.py\", line 205, in _run_trial\n",
            "    value_or_values = func(trial)\n",
            "                      ^^^^^^^^^^^\n",
            "  File \"/tmp/ipython-input-817022947.py\", line 20, in objective\n",
            "    model.fit(Pool(X_tr, y_tr), eval_set=Pool(X_val, y_val), early_stopping_rounds=50, verbose=False)\n",
            "  File \"/usr/local/lib/python3.12/dist-packages/catboost/core.py\", line 5873, in fit\n",
            "    return self._fit(X, y, cat_features, text_features, embedding_features, None, graph, sample_weight, None, None, None, None, baseline,\n",
            "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
            "  File \"/usr/local/lib/python3.12/dist-packages/catboost/core.py\", line 2410, in _fit\n",
            "    self._train(\n",
            "  File \"/usr/local/lib/python3.12/dist-packages/catboost/core.py\", line 1790, in _train\n",
            "    self._object._train(train_pool, test_pool, params, allow_clear_pool, init_model._object if init_model else None)\n",
            "  File \"_catboost.pyx\", line 5023, in _catboost._CatBoost._train\n",
            "  File \"_catboost.pyx\", line 5072, in _catboost._CatBoost._train\n",
            "_catboost.CatBoostError: catboost/cuda/cuda_lib/cuda_base.h:281: CUDA error 35: CUDA driver version is insufficient for CUDA runtime version\n",
            "[W 2025-11-29 12:02:20,398] Trial 0 failed with value None.\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "CatBoostError",
          "evalue": "catboost/cuda/cuda_lib/cuda_base.h:281: CUDA error 35: CUDA driver version is insufficient for CUDA runtime version",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mCatBoostError\u001b[0m                             Traceback (most recent call last)",
            "\u001b[0;32m/tmp/ipython-input-3346214142.py\u001b[0m in \u001b[0;36m<cell line: 0>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mstudy\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0moptuna\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcreate_study\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdirection\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'minimize'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mstudy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptimize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobjective\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_trials\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/optuna/study/study.py\u001b[0m in \u001b[0;36moptimize\u001b[0;34m(self, func, n_trials, timeout, n_jobs, catch, callbacks, gc_after_trial, show_progress_bar)\u001b[0m\n\u001b[1;32m    488\u001b[0m                 \u001b[0mIf\u001b[0m \u001b[0mnested\u001b[0m \u001b[0minvocation\u001b[0m \u001b[0mof\u001b[0m \u001b[0mthis\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0moccurs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    489\u001b[0m         \"\"\"\n\u001b[0;32m--> 490\u001b[0;31m         _optimize(\n\u001b[0m\u001b[1;32m    491\u001b[0m             \u001b[0mstudy\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    492\u001b[0m             \u001b[0mfunc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/optuna/study/_optimize.py\u001b[0m in \u001b[0;36m_optimize\u001b[0;34m(study, func, n_trials, timeout, n_jobs, catch, callbacks, gc_after_trial, show_progress_bar)\u001b[0m\n\u001b[1;32m     65\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mn_jobs\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 67\u001b[0;31m             _optimize_sequential(\n\u001b[0m\u001b[1;32m     68\u001b[0m                 \u001b[0mstudy\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m                 \u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/optuna/study/_optimize.py\u001b[0m in \u001b[0;36m_optimize_sequential\u001b[0;34m(study, func, n_trials, timeout, catch, callbacks, gc_after_trial, reseed_sampler_rng, time_start, progress_bar)\u001b[0m\n\u001b[1;32m    162\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    163\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 164\u001b[0;31m             \u001b[0mfrozen_trial_id\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_run_trial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstudy\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcatch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    165\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    166\u001b[0m             \u001b[0;31m# The following line mitigates memory problems that can be occurred in some\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/optuna/study/_optimize.py\u001b[0m in \u001b[0;36m_run_trial\u001b[0;34m(study, func, catch)\u001b[0m\n\u001b[1;32m    260\u001b[0m         \u001b[0;32mand\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc_err\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcatch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    261\u001b[0m     ):\n\u001b[0;32m--> 262\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mfunc_err\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    263\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mtrial\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trial_id\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    264\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/optuna/study/_optimize.py\u001b[0m in \u001b[0;36m_run_trial\u001b[0;34m(study, func, catch)\u001b[0m\n\u001b[1;32m    203\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mget_heartbeat_thread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrial\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trial_id\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstudy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_storage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    204\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 205\u001b[0;31m             \u001b[0mvalue_or_values\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrial\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    206\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mexceptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTrialPruned\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    207\u001b[0m             \u001b[0;31m# TODO(mamu): Handle multi-objective cases.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/tmp/ipython-input-817022947.py\u001b[0m in \u001b[0;36mobjective\u001b[0;34m(trial)\u001b[0m\n\u001b[1;32m     18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m     \u001b[0mmodel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mCatBoostRegressor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 20\u001b[0;31m     \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mPool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_tr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_tr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meval_set\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mPool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_val\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_val\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mearly_stopping_rounds\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m50\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     21\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     22\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_best_score\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'validation'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'RMSE'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/catboost/core.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, cat_features, text_features, embedding_features, graph, sample_weight, baseline, use_best_model, eval_set, verbose, logging_level, plot, plot_file, column_description, verbose_eval, metric_period, silent, early_stopping_rounds, save_snapshot, snapshot_file, snapshot_interval, init_model, callbacks, log_cout, log_cerr)\u001b[0m\n\u001b[1;32m   5871\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;34m'loss_function'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   5872\u001b[0m             \u001b[0mCatBoostRegressor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_check_is_compatible_loss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'loss_function'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 5873\u001b[0;31m         return self._fit(X, y, cat_features, text_features, embedding_features, None, graph, sample_weight, None, None, None, None, baseline,\n\u001b[0m\u001b[1;32m   5874\u001b[0m                          \u001b[0muse_best_model\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meval_set\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlogging_level\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mplot\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mplot_file\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcolumn_description\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   5875\u001b[0m                          \u001b[0mverbose_eval\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric_period\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msilent\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mearly_stopping_rounds\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/catboost/core.py\u001b[0m in \u001b[0;36m_fit\u001b[0;34m(self, X, y, cat_features, text_features, embedding_features, pairs, graph, sample_weight, group_id, group_weight, subgroup_id, pairs_weight, baseline, use_best_model, eval_set, verbose, logging_level, plot, plot_file, column_description, verbose_eval, metric_period, silent, early_stopping_rounds, save_snapshot, snapshot_file, snapshot_interval, init_model, callbacks, log_cout, log_cerr)\u001b[0m\n\u001b[1;32m   2408\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2409\u001b[0m             \u001b[0;32mwith\u001b[0m \u001b[0mplot_wrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mplot_file\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Training plots'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0m_get_train_dir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_params\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2410\u001b[0;31m                 self._train(\n\u001b[0m\u001b[1;32m   2411\u001b[0m                     \u001b[0mtrain_pool\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2412\u001b[0m                     \u001b[0mtrain_params\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"eval_sets\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/catboost/core.py\u001b[0m in \u001b[0;36m_train\u001b[0;34m(self, train_pool, test_pool, params, allow_clear_pool, init_model)\u001b[0m\n\u001b[1;32m   1788\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1789\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_train\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrain_pool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_pool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mallow_clear_pool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minit_model\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1790\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_object\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_train\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_pool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_pool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mallow_clear_pool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minit_model\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_object\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0minit_model\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1791\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_set_trained_model_attributes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1792\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m_catboost.pyx\u001b[0m in \u001b[0;36m_catboost._CatBoost._train\u001b[0;34m()\u001b[0m\n",
            "\u001b[0;32m_catboost.pyx\u001b[0m in \u001b[0;36m_catboost._CatBoost._train\u001b[0;34m()\u001b[0m\n",
            "\u001b[0;31mCatBoostError\u001b[0m: catboost/cuda/cuda_lib/cuda_base.h:281: CUDA error 35: CUDA driver version is insufficient for CUDA runtime version"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "best_params = study.best_params\n",
        "best_params.update({\n",
        "    'iterations' : 10000,\n",
        "    'loss_function': 'RMSE',\n",
        "    'eval_metric': 'RMSE',\n",
        "    'verbose': 100,\n",
        "    'early_stopping_rounds': 100,\n",
        "    'random_state': CFG.RANDOM_STATE,\n",
        "    'task_type': 'GPU' if 'GPU' in best_params.get('task_type', 'CPU') else 'CPU'\n",
        "})\n",
        "\n",
        "final_model = CatBoostRegressor(**best_params)\n",
        "final_model.fit(\n",
        "    Pool(X_train, y_train),\n",
        "    eval_set=Pool(X_test, y_test),\n",
        "    verbose=100,\n",
        "    early_stopping_rounds=100\n",
        ")\n"
      ],
      "metadata": {
        "id": "froDCYRNXQCU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"Статистика по nivel_y: {y_test.std():.4f}\")"
      ],
      "metadata": {
        "id": "lKEP-gOqXTLM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "y_pred = final_model.predict(X_test)\n",
        "mae = mean_absolute_error(y_test, y_pred)\n",
        "mean = np.mean(y_test - y_pred)\n",
        "std_err = np.std(y_pred)\n",
        "rmse = np.sqrt(mean_squared_error(y_test, y_pred))\n",
        "r2 = r2_score(y_test, y_pred)\n",
        "\n",
        "print(f\"\\n=== FINAL RESULTS ===\")\n",
        "print(f\"Test MEAN:  {mean:.4f}\")\n",
        "print(f\"Test MAE:  {mae:.4f}\")\n",
        "print(f\"Test RMSE: {rmse:.4f}\")\n",
        "print(f\"Test R²:   {r2:.4f}\")"
      ],
      "metadata": {
        "id": "rOPeaoqVXT2_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "import numpy as np\n",
        "\n",
        "# Убедимся, что y_test и y_pred — это массивы/серии с тем же индексом\n",
        "y_true = y_test.values\n",
        "y_pred = final_model.predict(X_test)\n",
        "errors = y_pred - y_true\n",
        "\n",
        "# Индексы измерений (можно использовать как \"время\" или порядковый номер)\n",
        "indices = np.arange(len(y_true))\n",
        "\n",
        "# Настройка стиля\n",
        "sns.set(style=\"whitegrid\", font_scale=1.2)\n",
        "fig, axes = plt.subplots(3, 1, figsize=(14, 12), sharex=True)\n",
        "\n",
        "# 1. Истина vs Прогноз (точечный график)\n",
        "ax = axes[0]\n",
        "ax.scatter(indices, y_true, label='Истина (nivel_y)', alpha=0.7, s=20, color='steelblue')\n",
        "ax.scatter(indices, y_pred, label='Прогноз', alpha=0.7, s=20, color='crimson')\n",
        "ax.set_ylabel('nivel_y (″)')\n",
        "ax.set_title('Истина и прогноз на тестовой выборке')\n",
        "ax.legend()\n",
        "ax.grid(True)\n",
        "\n",
        "# 2. Временной график (линии)\n",
        "ax = axes[1]\n",
        "ax.plot(indices, y_true, label='Истина', linewidth=1.2, color='steelblue')\n",
        "ax.plot(indices, y_pred, label='Прогноз', linewidth=1.2, color='crimson', linestyle='--')\n",
        "ax.set_ylabel('nivel_y (″)')\n",
        "ax.set_title('Динамика: истинные и предсказанные значения')\n",
        "ax.legend()\n",
        "ax.grid(True)\n",
        "\n",
        "# 3. Ошибка (разность)\n",
        "ax = axes[2]\n",
        "ax.plot(indices, errors, color='darkorange', linewidth=1.0)\n",
        "ax.axhline(0, color='black', linestyle='--', linewidth=0.8)\n",
        "ax.set_xlabel('Индекс измерения')\n",
        "ax.set_ylabel('Ошибка (″)')\n",
        "ax.set_title(f'Ошибка прогноза (RMSE = {np.sqrt(np.mean(errors**2)):.3f}″)')\n",
        "ax.grid(True)\n",
        "\n",
        "# Общая настройка\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "anCjze3fXX6T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# # 1. Сохранение лучшей модели\n",
        "\n",
        "\n",
        "# # Создаем папку для моделей если её нет\n",
        "# os.makedirs('./models', exist_ok=True)\n",
        "\n",
        "# # Сохраняем лучшую модель\n",
        "# model_path = './models/best_catboost_model_400600.pkl'\n",
        "# joblib.dump(final_model, model_path)\n",
        "# print(f\"Модель сохранена по пути: {model_path}\")"
      ],
      "metadata": {
        "id": "NThpRRlfXavl"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [
        "OvuseAcAwaou",
        "aAXorGOSpK9f"
      ],
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}