gusev_vladislav_lab_3 is ready

Reviewed-on: http://student.git.athene.tech/Alexey/IIS_2023_1/pulls/59

.idea/discord.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="DiscordProjectSettings">
+    <option name="show" value="ASK" />
+    <option name="description" value="" />
+  </component>
+</project>

.idea/misc.xml

@@ -1,4 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.8 (venv)" project-jdk-type="Python SDK" />
+  <component name="PyCharmProfessionalAdvertiser">
+    <option name="shown" value="true" />
+  </component>
 </project>

.idea/workspace.xml

@@ -1,7 +1,12 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="SELECTIVE" />
+  </component>
   <component name="ChangeListManager">
-    <list default="true" id="0ceb130e-88da-4a20-aad6-17f5ab4226ac" name="Changes" comment="" />
+    <list default="true" id="0ceb130e-88da-4a20-aad6-17f5ab4226ac" name="Changes" comment="">
+      <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
+    </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
     <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
@@ -15,23 +20,32 @@
     </option>
   </component>
   <component name="Git.Settings">
+    <option name="RECENT_BRANCH_BY_REPOSITORY">
+      <map>
+        <entry key="$PROJECT_DIR$" value="main" />
+      </map>
+    </option>
     <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
   </component>
   <component name="MarkdownSettingsMigration">
     <option name="stateVersion" value="1" />
   </component>
+  <component name="ProjectColorInfo">{
+  &quot;associatedIndex&quot;: 2
+}</component>
   <component name="ProjectId" id="2VlZqWiOX68aCf0o2y0AtYJWURS" />
   <component name="ProjectViewState">
     <option name="hideEmptyMiddlePackages" value="true" />
     <option name="showLibraryContents" value="true" />
   </component>
-  <component name="PropertiesComponent"><![CDATA[{
-  "keyToString": {
-    "RunOnceActivity.OpenProjectViewOnStart": "true",
-    "RunOnceActivity.ShowReadmeOnStart": "true",
-    "last_opened_file_path": "D:/ulstukek/Course4/IIS/labs"
+  <component name="PropertiesComponent">{
+  &quot;keyToString&quot;: {
+    &quot;RunOnceActivity.OpenProjectViewOnStart&quot;: &quot;true&quot;,
+    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
+    &quot;last_opened_file_path&quot;: &quot;D:/ulstukek/Course4/IIS/labs&quot;,
+    &quot;settings.editor.selected.configurable&quot;: &quot;reference.settings.ide.settings.new.ui&quot;
   }
-}]]></component>
+}</component>
   <component name="RecentsManager">
     <key name="CopyFile.RECENT_KEYS">
       <recent name="D:\ulstukek\Course4\IIS\IISLabs\IIS_2023_1\zavrazhnova_svetlana_lab_3" />
@@ -104,9 +118,11 @@
     </configuration>
     <recent_temporary>
       <list>
-        <item itemvalue="Python.zavrazhnova_svetlana_lab3_2" />
         <item itemvalue="Python.zavrazhnova_svetlana_lab_3_1" />
         <item itemvalue="Python.zavrazhnova_svetlana_lab_2" />
+        <item itemvalue="Python.zavrazhnova_svetlana_lab3_2" />
+        <item itemvalue="Python.zavrazhnova_svetlana_lab3_2" />
+        <item itemvalue="Python.zavrazhnova_svetlana_lab_3_1" />
       </list>
     </recent_temporary>
   </component>

abanin_daniil_lab_1/README.md

@@ -0,0 +1,47 @@
+## Лабораторная работа №1
+
+### Работа с типовыми наборами данных и различными моделями
+
+### ПИбд-41 Абанин Даниил
+
+### Как запустить лабораторную работу:
+
+* установить python, numpy, matplotlib, sklearn
+* запустить проект (стартовая точка класс lab1)
+
+### Какие технологии использовались:
+
+* Язык программирования `Python`, 
+* Библиотеки numpy, matplotlib, sklearn
+* Среда разработки `PyCharm`
+
+### Что делает лабораторная работа:
+
+* Программа гененерирует данные с make_moonsmake_moons (noise=0.3, random_state=rs)
+* Сравнивает три типа моделей: инейная, полиномиальная, гребневая полиномиальная регрессии
+
+### Примеры работы:
+
+#### Результаты:
+MAE - средняя абсолютная ошибка, измеряет среднюю абсолютную разницу между прогнозируемыми значениями модели и фактическими значениями целевой переменной
+MSE - средняя квадратическая ошибка, измеряет среднюю квадратичную разницу между прогнозируемыми значениями модели и фактическими значениями целевой переменной
+
+Чем меньше значения показателей, тем лучше модель справляется с предсказанием
+
+Линейная регрессия
+MAE 0.2959889435199454
+MSE 0.13997968555679302
+
+Полиномиальная регрессия
+MAE 0.21662135861071705
+MSE 0.08198825629271855
+
+Гребневая полиномиальная регрессия
+MAE 0.2102788716636562
+MSE 0.07440133949387796
+
+Лучший результат показала модель **Гребневая полиномиальная регрессия**
+
+![Lin](lin_reg.jpg)
+![Pol](pol_reg.jpg)
+![Greb](greb_reg.jpg)

abanin_daniil_lab_1/lab1.py

@@ -0,0 +1,66 @@
+from matplotlib import pyplot as plt
+from matplotlib.colors import ListedColormap
+from sklearn.linear_model import LinearRegression, Ridge
+from sklearn.model_selection import train_test_split
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.datasets import make_moons
+from sklearn import metrics
+
+cm_bright = ListedColormap(['#8B0000', '#FF0000'])
+cm_bright1 = ListedColormap(['#FF4500', '#FFA500'])
+
+
+def create_moons():
+    x, y = make_moons(noise=0.3, random_state=0)
+    X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=.4, random_state=42)
+
+    linear_regretion(X_train, X_test, y_train, y_test)
+    polynomial_regretion(X_train, X_test, y_train, y_test)
+    ridge_regretion(X_train, X_test, y_train, y_test)
+
+
+def linear_regretion(x_train, x_test, y_train, y_test):
+    model = LinearRegression().fit(x_train, y_train)
+    y_predict = model.intercept_ + model.coef_ * x_test
+    plt.title('Линейная регрессия')
+    print('Линейная регрессия')
+    plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train, cmap=cm_bright)
+    plt.scatter(x_test[:, 0], x_test[:, 1], c=y_test, cmap=cm_bright1, alpha=0.7)
+    plt.plot(x_test, y_predict, color='red')
+    print('MAE', metrics.mean_absolute_error(y_test, y_predict[:, 1]))
+    print('MSE', metrics.mean_squared_error(y_test, y_predict[:, 1]))
+    plt.show()
+
+
+def polynomial_regretion(x_train, x_test, y_train, y_test):
+    polynomial_features = PolynomialFeatures(degree=3)
+    X_polynomial = polynomial_features.fit_transform(x_train, y_train)
+    base_model = LinearRegression()
+    base_model.fit(X_polynomial, y_train)
+    y_predict = base_model.predict(X_polynomial)
+    plt.title('Полиномиальная регрессия')
+    plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train, cmap=cm_bright)
+    plt.scatter(x_test[:, 0], x_test[:, 1], c=y_test, cmap=cm_bright1, alpha=0.7)
+    plt.plot(x_train, y_predict, color='blue')
+    plt.show()
+    print('Полиномиальная регрессия')
+    print('MAE', metrics.mean_absolute_error(y_train, y_predict))
+    print('MSE', metrics.mean_squared_error(y_train, y_predict))
+
+
+def ridge_regretion(X_train, X_test, y_train, y_test):
+    model = Pipeline([('poly', PolynomialFeatures(degree=3)), ('ridge', Ridge(alpha=1.0))])
+    model.fit(X_train, y_train)
+    y_predict = model.predict(X_test)
+    plt.title('Гребневая полиномиальная регрессия')
+    plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright)
+    plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright1, alpha=0.7)
+    plt.plot(X_test, y_predict, color='blue')
+    plt.show()
+    print('Гребневая полиномиальная регрессия')
+    print('MAE', metrics.mean_absolute_error(y_test, y_predict))
+    print('MSE', metrics.mean_squared_error(y_test, y_predict))
+
+
+create_moons()

abanin_daniil_lab_2/README.md

@@ -0,0 +1,41 @@
+## Лабораторная работа №2
+
+### Ранжирование признаков
+
+## ПИбд-41 Абанин Даниил
+
+### Как запустить лабораторную работу:
+
+* установить python, numpy, matplotlib, sklearn
+* запустить проект (стартовая точка lab2)
+
+### Какие технологии использовались:
+
+* Язык программирования `Python`, библиотеки numpy, matplotlib, sklearn
+* Среда разработки `PyCharm`
+
+### Что делает лабораторная работа:
+
+* Генерирует данные и обучает такие модели, как: LinearRegression, RandomizedLasso, Recursive Feature Elimination (RFE)
+* Производиться ранжирование признаков с помощью моделей LinearRegression, RandomizedLasso, Recursive Feature Elimination (RFE)
+* Отображение получившихся результатов: 4 самых важных признака по среднему значению, значения признаков для каждой модели
+
+
+### 4 самых важных признака по среднему значению
+* Параметр - x4, значение - 0.56
+* Параметр - x1, значение - 0.45
+* Параметр - x2, значение - 0.33
+* Параметр - x9, значение - 0.33
+
+####Linear Regression
+[('x1', 1.0), ('x4', 0.69), ('x2', 0.61), ('x11', 0.59), ('x3', 0.51), ('x13', 0.48), ('x5', 0.19), ('x12', 0.19), ('x14', 0.12), ('x8', 0.03), ('x6', 0.02), ('x10', 0.01), ('x7', 0.0), ('x9', 0.0)]
+
+####Recursive Feature Elimination
+[('x9', 1.0), ('x7', 0.86), ('x10', 0.71), ('x6', 0.57), ('x8', 0.43), ('x14', 0.29), ('x12', 0.14), ('x1', 0.0), ('x2', 0.0), ('x3', 0.0), ('x4', 0.0), ('x5', 0.0), ('x11', 0.0), ('x13', 0.0)]
+
+####Randomize Lasso
+[('x4', 1.0), ('x2', 0.37), ('x1', 0.36), ('x5', 0.32), ('x6', 0.02), ('x8', 0.02), ('x3', 0.01), ('x7', 0.0), ('x9', 0.0), ('x10', 0.0), ('x11', 0.0), ('x12', 0.0), ('x13', 0.0), ('x14', 0.0)]
+
+#### Результаты:
+
+![Result](result.png)

abanin_daniil_lab_2/RadomizedLasso.py

@@ -0,0 +1,76 @@
+from sklearn.utils import check_X_y, check_random_state
+from sklearn.linear_model import Lasso
+from scipy.sparse import issparse
+from scipy import sparse
+
+
+def _rescale_data(x, weights):
+    if issparse(x):
+        size = weights.shape[0]
+        weight_dia = sparse.dia_matrix((1 - weights, 0), (size, size))
+        x_rescaled = x * weight_dia
+    else:
+        x_rescaled = x * (1 - weights)
+
+    return x_rescaled
+
+
+class RandomizedLasso(Lasso):
+    """
+    Randomized version of scikit-learns Lasso class.
+
+    Randomized LASSO is a generalization of the LASSO. The LASSO penalises
+    the absolute value of the coefficients with a penalty term proportional
+    to `alpha`, but the randomized LASSO changes the penalty to a randomly
+    chosen value in the range `[alpha, alpha/weakness]`.
+
+    Parameters
+    ----------
+    weakness : float
+        Weakness value for randomized LASSO. Must be in (0, 1].
+
+    See also
+    --------
+    sklearn.linear_model.LogisticRegression : learns logistic regression models
+    using the same algorithm.
+    """
+    def __init__(self, weakness=0.5, alpha=1.0, fit_intercept=True,
+                 precompute=False, copy_X=True, max_iter=1000,
+                 tol=1e-4, warm_start=False, positive=False,
+                 random_state=None, selection='cyclic'):
+        self.weakness = weakness
+        super(RandomizedLasso, self).__init__(
+            alpha=alpha, fit_intercept=fit_intercept, precompute=precompute, copy_X=copy_X,
+            max_iter=max_iter, tol=tol, warm_start=warm_start,
+            positive=positive, random_state=random_state,
+            selection=selection)
+
+    def fit(self, X, y):
+        """Fit the model according to the given training data.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix}, shape = [n_samples, n_features]
+            The training input samples.
+
+        y : array-like, shape = [n_samples]
+            The target values.
+        """
+        if not isinstance(self.weakness, float) or not (0.0 < self.weakness <= 1.0):
+            raise ValueError('weakness should be a float in (0, 1], got %s' % self.weakness)
+
+        X, y = check_X_y(X, y, accept_sparse=True)
+
+        n_features = X.shape[1]
+        weakness = 1. - self.weakness
+        random_state = check_random_state(self.random_state)
+
+        weights = weakness * random_state.randint(0, 1 + 1, size=(n_features,))
+
+        # TODO: I am afraid this will do double normalization if set to true
+        #X, y, _, _ = _preprocess_data(X, y, self.fit_intercept, normalize=self.normalize, copy=False,
+        #             sample_weight=None, return_mean=False)
+
+        # TODO: Check if this is a problem if it happens before standardization
+        X_rescaled = _rescale_data(X, weights)
+        return super(RandomizedLasso, self).fit(X_rescaled, y)

abanin_daniil_lab_2/lab2.py

@@ -0,0 +1,81 @@
+from matplotlib import pyplot as plt
+from sklearn.linear_model import LinearRegression
+from RadomizedLasso import RandomizedLasso
+from sklearn.feature_selection import RFE
+from sklearn.preprocessing import MinMaxScaler
+import numpy as np
+
+names = ["x%s" % i for i in range(1, 15)]
+
+
+def start_point():
+    X,Y = generation_data()
+    # Линейная модель
+    lr = LinearRegression()
+    lr.fit(X, Y)
+    # Рекурсивное сокращение признаков
+    rfe = RFE(lr)
+    rfe.fit(X, Y)
+    # Случайное Лассо
+    randomized_lasso = RandomizedLasso(alpha=.01)
+    randomized_lasso.fit(X, Y)
+
+    ranks = {"Linear Regression": rank_to_dict(lr.coef_), "Recursive Feature Elimination": rank_to_dict(rfe.ranking_),
+             "Randomize Lasso": rank_to_dict(randomized_lasso.coef_)}
+
+    get_estimation(ranks)
+    print_sorted_data(ranks)
+
+
+def generation_data():
+    np.random.seed(0)
+    size = 750
+    X = np.random.uniform(0, 1, (size, 14))
+    Y = (10 * np.sin(np.pi * X[:, 0] * X[:, 1]) + 20 * (X[:, 2] - .5) ** 2 +
+         10 * X[:, 3] + 5 * X[:, 4] ** 5 + np.random.normal(0, 1))
+    X[:, 10:] = X[:, :4] + np.random.normal(0, .025, (size, 4))
+    return X, Y
+
+
+def rank_to_dict(ranks):
+    ranks = np.abs(ranks)
+    minmax = MinMaxScaler()
+    ranks = minmax.fit_transform(np.array(ranks).reshape(14, 1)).ravel()
+    ranks = map(lambda x: round(x, 2), ranks)
+    return dict(zip(names, ranks))
+
+
+def get_estimation(ranks: {}):
+    mean = {}
+    #«Бежим» по списку ranks
+    for key, value in ranks.items():
+        for item in value.items():
+            if(item[0] not in mean):
+                mean[item[0]] = 0
+            mean[item[0]] += item[1]
+
+    for key, value in mean.items():
+        res = value/len(ranks)
+        mean[key] = round(res, 2)
+
+    mean_sorted = sorted(mean.items(), key=lambda item: item[1], reverse=True)
+    print("Средние значения")
+    print(mean_sorted)
+
+
+    print("4 самых важных признака по среднему значению")
+    for item in mean_sorted[:4]:
+        print('Параметр - {0}, значение - {1}'.format(item[0], item[1]))
+
+
+
+def print_sorted_data(ranks: {}):
+    print()
+    for key, value in ranks.items():
+        ranks[key] = sorted(value.items(), key=lambda item: item[1], reverse=True)
+    for key, value in ranks.items():
+        print(key)
+        print(value)
+
+
+start_point()

alexandrov_dmitrii_lab_4/lab4.py

@@ -0,0 +1,40 @@
+from scipy.cluster import hierarchy
+import pandas as pd
+from matplotlib import pyplot as plt
+
+
+def start():
+    data = pd.read_csv('sberbank_data.csv', index_col='id')
+    x = data[['full_sq', 'price_doc']]
+    plt.figure(1, figsize=(16, 9))
+    plt.title('Дендрограмма кластеризации цен')
+
+    prices = [0, 0, 0, 0]
+    for ind, val in x.iterrows():
+        val = val['price_doc'] / val['full_sq']
+        if val < 100000:
+            prices[0] = prices[0] + 1
+        elif val < 300000:
+            prices[1] = prices[1] + 1
+        elif val < 500000:
+            prices[2] = prices[2] + 1
+        else:
+            prices[3] = prices[3] + 1
+    print('Результаты подчсёта ручного распределения:')
+    print('низких цен:'+str(prices[0]))
+    print('средних цен:'+str(prices[1]))
+    print('высоких цен:'+str(prices[2]))
+    print('премиальных цен:'+str(prices[3]))
+
+    hierarchy.dendrogram(hierarchy.linkage(x, method='single'),
+                         truncate_mode='lastp',
+                         p=15,
+                         orientation='top',
+                         leaf_rotation=90,
+                         leaf_font_size=8,
+                         show_contracted=True)
+
+    plt.show()
+
+
+start()

alexandrov_dmitrii_lab_4/readme.md

@@ -0,0 +1,27 @@
+### Задание
+Использовать метод кластеризации по варианту для выбранных данных по варианту, самостоятельно сформулировав задачу.
+Интерпретировать результаты и оценить, насколько хорошо он подходит для
+решения сформулированной вами задачи.
+
+Вариант 1: dendrogram
+
+Была сформулирована следующая задача: необходимо разбить записи на кластеры в зависимости от цен и площади.
+
+### Запуск программы
+Файл lab4.py содержит и запускает программу, аргументов и настройки ~~вроде~~ не требует.
+
+### Описание программы
+Программа считывает цены и площади из файла статистики сбербанка по рынку недвижимости.
+Поскольку по заданию требуется оценить машинную кластеризацию, для сравнения программа подсчитывает и выводит в консоль количество записей в каждом из выделенных вручную классов цен.
+Далее программа кластеризует данные с помощью алгоритма ближайших точек (на другие памяти нету) и выводит дендрограмму на основе кластеризации.
+Выводимая дендрограмма ограничена 15 последними (верхними) объединениями.
+
+### Результаты тестирования
+По результатам тестирования, можно сказать следующее:
+* Последние объединения в дендрограмме - объединения выбросов с 'основным' кластером, то есть 10-20 записей с кластером с более чем 28000 записями.
+* Это правильная информация, так как ручная классификация показывает, что премиальных (аномально больших) цен как раз порядка 20, остальные относятся к другим классам.
+* Поскольку в имеющихся данных нет ограничений по ценам, выбросы аномально высоких цен при использовании данного алгоритма формируют отдельные кластеры, что негативно сказывается на наглядности.
+* Ценовое ограничение также не дало положительнх результатов: снова сформировался 'основной' кластер, с которым последними объединялись отдельные значения.
+* Значит, сам алгоритм не эффективен.
+
+Итого: Алгоритм ближайших точек слишком чувствителен к выбросам, поэтому можно признать его неэффективным для необработанных данных. Дендрограмма как средство визуализации скорее уступает по наглядности диаграмме рассеяния.

alexandrov_dmitrii_lab_5/lab5.py

@@ -0,0 +1,48 @@
+from matplotlib import pyplot as plt
+from sklearn import metrics
+from sklearn.linear_model import LinearRegression
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.pipeline import Pipeline
+import pandas as pd
+
+
+def start():
+    data = pd.read_csv('sberbank_data.csv', index_col='id')
+    x = data[['timestamp', 'full_sq', 'floor', 'max_floor', 'build_year', 'num_room', 'material', 'kremlin_km']]
+    y = data[['price_doc']]
+
+    x = x.replace('NA', 0)
+    x.fillna(0, inplace=True)
+
+    col_date = []
+
+    for val in x['timestamp']:
+        col_date.append(val.split('-', 1)[0])
+
+    x = x.drop(columns='timestamp')
+    x['timestamp'] = col_date
+
+    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.01, random_state=42)
+
+    poly = Pipeline([('poly', PolynomialFeatures(degree=3)),
+                     ('linear', LinearRegression())])
+    poly.fit(x_train, y_train)
+
+    y_mean = y['price_doc'].mean()
+    y_predicted = poly.predict(x_test)
+    for i, n in enumerate(y_predicted):
+        if n < 10000:
+            y_predicted[i] = y_mean
+
+    print('Оценка обучения:')
+    print(metrics.r2_score(y_test, y_predicted))
+
+    plt.figure(1, figsize=(16, 9))
+    plt.title('Сравнение результатов обучения')
+    plt.scatter(x=[i for i in range(len(y_test))], y=y_test, c='g', s=5)
+    plt.scatter(x=[i for i in range(len(y_test))], y=y_predicted, c='r', s=5)
+    plt.show()
+
+
+start()

alexandrov_dmitrii_lab_5/readme.md

@@ -0,0 +1,36 @@
+### Задание
+Использовать регрессию по варианту для выбранных данных по варианту, самостоятельно сформулировав задачу.
+Интерпретировать результаты и оценить, насколько хорошо она подходит для
+решения сформулированной вами задачи.
+
+Вариант 1: полиномиальная регрессия
+
+Была сформулирована следующая задача: необходимо предсказывать стоимость жилья по избранным признакам при помощи регрессии.
+
+### Запуск программы
+Файл lab5.py содержит и запускает программу, аргументов и настройки ~~вроде~~ не требует.
+
+### Описание программы
+Программа считывает цены на жильё как выходные данные и следующие данные как входные: год размещения объявления, площадь, этаж, количество этажей, год постройки, количество комнат, материал, расстояние до кремля (условного центра).
+Далее она обрабатывает данные (цифровизирует нулевые данные), оставляет только год объявления.
+
+После обработки программа делит данные на 99% обучающего материала и 1% тестового и обучает модель полиномиальной регрессии со степенью 3.
+Далее модель генерирует набор предсказаний на основе тестовых входных данных. Эти предсказания обрабатываются: убираются отрицательные цены.
+
+Далее программа оценивает предсказания по коэффициенту детерминации и выводит результат в консоль. А также показывает диаграммы рассеяния для действительных (зелёные точки) и предсказанных (красные точки) цен.
+
+### Результаты тестирования
+По результатам тестирования, можно сказать следующее:
+* Полные данные алгоритм обрабатывает плохо, поэтому было необходимо было выбирать наиболее значимые признаки.
+* В зависимости от данных, разные степени регрессии дают разный результат. В общем случае обычная линейная регрессия давала коэффициент около 0.3. При добавлении же степеней полиномиальная регрессия выдавала выбросные значения цен: например, -300 миллионов, что негативно сказывалось на результате.
+* Для того, чтобы явно выбросные результаты не портили оценку (коэффициент соответственно становился -1000) эти выбросные значения заменялись на средние.
+* Опытным путём было найдено, что наилучшие результаты (коэффициент 0.54) показывает степень 3.
+* Результат  0.54 - наилучший результат - можно назвать неприемлимым: только в половине случаев предсказанная цена условно похожа на действительную.
+* Возможно, включением большего количества признаков и использованием других моделей (линейная, например, не давала выбросов) удастся решить проблему.
+
+Пример консольного вывода:
+>Оценка обучения:
+>
+>0.5390648784908953
+
+Итого: Алгоритм можно привести к некоторой эффективности, однако для конкретно этих данных он не подходит. Лучше попытаться найти другую модель регрессии.

antonov_dmitry_lab_7/README.md

@@ -0,0 +1,115 @@
+# Лаб 7 RNN
+
+Выбрать художественный текст (четные варианты – русскоязычный,
+нечетные – англоязычный) и обучить на нем рекуррентную нейронную сеть
+для решения задачи генерации. Подобрать архитектуру и параметры так,
+чтобы приблизиться к максимально осмысленному результату. Далее
+разбиться на пары четный-нечетный вариант, обменяться разработанными
+сетями и проверить, как архитектура товарища справляется с вашим текстом.
+В завершении подобрать компромиссную архитектуру, справляющуюся
+достаточно хорошо с обоими видами текстов.
+
+# Вариант 3
+
+Рекуррентная нейронная сеть и задача
+генерации текста
+
+# Запуск
+
+Выполнением скрипта файла (вывод в консоль).
+
+# Описание модели:
+
+Использованы библиотеки:
+* numpy (np): популярная библиотека для научных вычислений.
+* tensorflow (tf): библиотека для тренировки нейросетей.
+* Sequential: тип Keras модель которая позволяет создавать нейросети слой за слоем.
+* Embedding, LSTM, Dense: различные типы слоев в нейросетях.
+* Tokenizer: класс для конвертации слов в числовой понятный для нейросети формат.
+<p></p>
+Каждая строка текста переводится в числа с помощью Tokernizer.
+Класс Tokenizer в Keras - это утилита обработки текста, которая преобразует текст в 
+последовательность целых чисел. Он присваивает уникальное целое число (индекс) каждому слову 
+в тексте и создает словарь, который сопоставляет каждое слово с соответствующим индексом. 
+Это позволяет вам работать с текстовыми данными в формате, который может быть передан в нейронную сеть.
+Все это записывается в input_sequences.
+
+Строим RNN модель используя Keras:
+
+* Embedding: Этот слой превращает числа в векторы плотности фиксированного размера. Так же известного
+как "word embeddings". Вложения слов - это плотные векторные представления слов в непрерывном 
+векторном пространстве.Они позволяют нейронной сети изучать и понимать взаимосвязи между словами 
+на основе их контекста в содержании текста. 
+* LSTM: это тип рекуррентной нейронной сети (RNN), которая предназначена для обработки 
+зависимостей в последовательностях.
+* Dense: полносвязный слой с множеством нейронов, нейронов столько же сколько и уникальных слов. 
+Он выводит вероятность следующего слова.
+
+* Модель обучаем на разном количестве эпох, по умолчанию epochs = 100 (итераций по всему набору данных).
+
+Определеяем функцию generate_text которая принимает стартовое слово, а также, число слов для генерации.
+Модель генерирует текст путем многократного предсказания следующего слова на основе предыдущих слов в
+начальном тексте.
+
+* В конце мы получаем сгенерированную на основе текста последовательность.
+
+# Задача генерации англоязычного текста
+На вход подаем историю с похожими повторяющимися слова. Историю сохраняем в файл.
+Задача проверить насколько сеть не станет повторять текст, а будет действительно генерировать
+относительно новый текст.
+
+# Результаты
+Тестируется английский текст, приложенный в репозитории.
+* на 50 эпохах ответ на I want
+* I want to soar high up in the sky like to glide through the clouds feeling the wind beneath my wings i want to fly i want to fly i want to fly i want to fly i want to fly i want to fly i want to fly i want to
+* на 100 эпох ответ на I want
+* I want to fly i want to soar high up in the sky like a bird to glide through the clouds feeling the wind beneath my wings i want to fly i want to fly i want to spread my wings and soar into the open sky to glide far above the
+* на 150 эпохах ответ на I want
+* I want to fly i want to spread my wings and soar into the open sky to glide far above the earth unbounded by gravity i want to fly i want to fly i want to fly i want to soar high up in the sky like a bird to glide through
+* на 220 эпохах ответ на I want
+* I want to fly i want to soar high up in the sky like a bird to glide through the clouds feeling the wind beneath my wings i want to fly i want to fly i want to fly i want to fly i want to fly i want to fly i
+
+* На 220 эпохах результаты хуже, это произошло скорее всего из-за переобучения(грубый повтор).
+* На 50 эпохах нейронная сеть плохо обучена (из 1 места плюс повтор)
+* На 100 эпохах средний результат (из 2 мест)
+* На 150 эпохах нейронная сеть показывает наилучший результат (из 3 разных мест без повтора)
+
+Так же модель работает и на русском тексте. Вот что сгенерировала модель на 150 эпохах. 
+Предложения взяты из разных мест и выглядят осмысленно.
+"Я хочу летать потому что в этом заложено желание преодолевать границы хочу чувствовать себя 
+свободным словно ветер несущим меня к новым приключениям я хочу летать и продолжать этот бескрайний 
+полет вперед ибо в этом полете заключена вся суть моего существования существования существования 
+существования существования трудности трудности трудности неважными хочу летать потому что."
+
+Чем больше текст мы берем, тем более интересные результаты получаем, но моих вычислительных мощностей уже не хватит.
+Так же чем больше прогонов, тем лучше модель, но тоже не до бесконечности можно получить хороший результат.
+<p>
+    <div>Обучение</div>
+    <img src="screens/img_2.png" width="650" title="Обучение">
+</p>
+
+<p>
+    <div>Результат</div>
+    <img src="screens/img_3.png" width="650" title="Результат">
+</p>
+
+<p>
+    <div>Обучение 1</div>
+    <img src="screens/step1.png" width="650" title="Обучение 1">
+</p>
+<p>
+    <div>Обучение 2</div>
+    <img src="screens/step2.png" width="650" title="Обучение 2">
+</p>
+<p>
+    <div>Обучение 3</div>
+    <img src="screens/step3.png" width="650" title="Обучение 3">
+</p>
+<p>
+    <div>Обучение 4</div>
+    <img src="screens/step4.png" width="650" title="Обучение 4">
+</p>
+<p>
+    <div>Обучение 5</div>
+    <img src="screens/step5.png" width="650" title="Обучение 5">
+</p>

antonov_dmitry_lab_7/lab7.py

@@ -0,0 +1,55 @@
+import numpy as np
+from keras.models import Sequential
+from keras.layers import Embedding, LSTM, Dense
+from keras.preprocessing.text import Tokenizer
+from keras_preprocessing.sequence import pad_sequences
+
+# загрузка текста
+with open('rus.txt', encoding='utf-8') as file:
+    text = file.read()
+
+tokenizer = Tokenizer()
+tokenizer.fit_on_texts([text])
+total_words = len(tokenizer.word_index) + 1
+
+input_sequences = []
+for line in text.split('\n'):
+    token_list = tokenizer.texts_to_sequences([line])[0]
+    for i in range(1, len(token_list)):
+        n_gram_sequence = token_list[:i + 1]
+        input_sequences.append(n_gram_sequence)
+
+max_sequence_length = max([len(x) for x in input_sequences])
+input_sequences = pad_sequences(input_sequences, maxlen=max_sequence_length, padding='pre')
+
+predictors, labels = input_sequences[:, :-1], input_sequences[:, -1]
+
+# создание RNN модели
+model = Sequential()
+model.add(Embedding(total_words, 100, input_length=max_sequence_length - 1))
+model.add(LSTM(150))
+model.add(Dense(total_words, activation='softmax'))
+
+model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+
+# тренировка модели
+model.fit(predictors, labels, epochs=150, verbose=1)
+
+
+# генерация текста на основе модели
+def generate_text(seed_text, next_words, model, max_sequence_length):
+    for _ in range(next_words):
+        token_list = tokenizer.texts_to_sequences([seed_text])[0]
+        token_list = pad_sequences([token_list], maxlen=max_sequence_length - 1, padding='pre')
+        predicted = np.argmax(model.predict(token_list), axis=-1)
+        output_word = ""
+        for word, index in tokenizer.word_index.items():
+            if index == predicted:
+                output_word = word
+                break
+        seed_text += " " + output_word
+    return seed_text
+
+
+generated_text = generate_text("Я хочу", 50, model, max_sequence_length)
+print(generated_text)

antonov_dmitry_lab_7/rus.txt

@@ -0,0 +1,11 @@
+Я хочу летать. Почувствовать ветер в лицо, свободно парить в небесах. Я хочу летать, словно птица, освободившись от земных оков. Летать, словно орел, покоряя небесные просторы. Я хочу летать, чувствовать каждый момент поднятия в воздух, каждый поворот, каждое крыло, взмахнувшее в танце с аэродинамикой.
+
+Я хочу летать над горами, смотреть на вершины, которые кажутся такими далекими с земли. Хочу летать над океанами, наблюдая за волнами, встречая закаты, окрашивающие водную гладь в огонь. Я хочу летать над городами, где жизнь бурлит своим ритмом, а улицы выглядят как мозаика, расстилающаяся под ногами.
+
+Я хочу летать, ощущать тот подъем, когда ты понимаешь, что земля осталась позади, а ты – свободен, как никогда. Я хочу летать и видеть этот мир с высоты, где все проблемы кажутся такими маленькими и неважными. Хочу летать и чувствовать себя частью этого огромного космического танца, где звезды танцуют свои вечерние вальсы.
+
+Я хочу летать, несмотря ни на что, преодолевая любые преграды. Хочу летать, потому что в этом чувствую свое настоящее "я". Летать – значит освобождаться от гравитации рутины, подниматься над повседневностью, смотреть на мир с высоты своей мечты.
+
+Я хочу летать, потому что в этом заключена свобода души. Хочу ощутить, как воздух обволакивает меня, как каждая клетка моего тела ощущает эту свободу. Хочу летать, потому что это моя мечта, которая дает мне силы двигаться вперед, преодолевая все трудности.
+
+Я хочу летать, потому что в этом заложено желание преодолевать границы. Хочу чувствовать себя свободным, словно ветер, несущим меня к новым приключениям. Я хочу летать и продолжать этот бескрайний полет вперед, ибо в этом полете заключена вся суть моего существования.

antonov_dmitry_lab_7/small.txt

@@ -0,0 +1,16 @@
+I want to fly. I want to soar high up in the sky like a bird. To glide through the clouds, feeling the wind beneath my wings. I want to fly.
+
+I imagine what it would be like, to be able to spread my arms and take off into the endless blue. To swoop and dive and twirl through the air unencumbered by gravity's pull. I want to fly.
+
+I watch the birds outside my window, floating effortlessly on the breeze. How I wish I could join them up there. To break free of the bounds of this earth and taste the freedom of flight. I want to fly.
+
+Over and over I dream of flying. I flap my arms but remain stuck to the ground. Still I gaze up hopefully at the sky. One day, I tell myself. One day I will fly. I want to fly.
+I want to fly. I want to spread my wings and soar into the open sky. To glide far above the earth unbounded by gravity. I want to fly.
+
+Ever since I was a child I've dreamed of flying. I would flap my arms trying in vain to take off. I envied the birds and their gift of flight. On windy days, I'd run with the breeze, hoping it would lift me up. But my feet stayed planted. Still my desire to fly remained.
+
+As I grew up, my dreams of flying never left. I'd gaze out plane windows high above the earth and ache to sprout wings. I'd watch birds for hours wishing I could join their effortless flight. At night I'd have vivid dreams of gliding among the clouds. Then I'd awake still earthbound and sigh. My longing to fly unchanged.
+
+I want to know what it feels like to swoop and dive through the air. To loop and twirl on the wind currents with ease. To soar untethered by gravity's grip. But I'm trapped on the ground, wings useless and weighted. Still I stare upwards hoping. Still I imagine what could be. Still I want to fly.
+
+They say it's impossible, that humans aren't meant for flight. But I refuse to let go of this dream. I gaze up, envying the way the birds own the sky while my feet stay planted. I flap and I hope. And still I want to fly.

arutunyan_dmitry_lab_2/README.md

@@ -0,0 +1,109 @@
+
+## Лабораторная работа 2. Вариант 4.
+### Задание 
+Выполнить ранжирование признаков. Отобразить получившиеся значения\оценки каждого признака каждым методом\моделью и среднюю оценку. Провести анализ получившихся результатов. Какие четыре признака оказались самыми важными по среднему значению? 
+
+Модели:
+
+- Гребневая регрессия `Ridge`, 
+- Случайное Лассо `RandomizedLasso`, 
+- Рекурсивное сокращение признаков `Recursive Feature Elimination – RFE`
+
+> **Warning**
+>
+> Модель "случайное лассо" `RandomizedLasso` была признана устаревшей в бибилотеке `scikit` версии 0.20. Её безболезненной заменой назван регрессор случайного леса `RandomForestRegressor`. Он будет использоваться в данной лабораторной вместо устаревшей функции.
+
+### Как запустить
+Для запуска программы необходимо с помощью командной строки в корневой директории файлов прокета прописать:
+```
+python main.py
+```
+
+### Используемые технологии
+- Библиотека `numpy`, используемая для обработки массивов данных и вычислений
+- Библиотека `sklearn` - большой набор функционала для анализа данных. Из неё были использованы инструменты:
+    - `LinearRegression` - инструмент работы с моделью "Линейная регрессия"
+    - `Ridge` - инструмент работы с моделью "Гребневая регрессия"
+    - `RFE` - инструмент оценки важности признаков "Рекурсивное сокращение признаков"
+    - `RandomForestRegressor` - инструмент работы с моделью "Регрессор случайного леса"
+    - `MinMaxScaler` - инструмент масштабирования значений в заданный диапазон
+
+### Описание работы
+Программа генерирует данные для обучения моделей. Сначала генерируются признаки в количестве 14-ти штук, важность которых модели предстоит выявить.
+```python
+np.random.seed(0)
+size = 750
+X = np.random.uniform(0, 1, (size, 14))
+```
+Затем задаётся функция зависимости выходных параметров от входных, представляющая собой регриссионную проблему Фридмана.
+```python
+Y = (10 * np.sin(np.pi * X[:, 0] * X[:, 1]) + 20 * (X[:, 2] - .5) ** 2 +
+     10 * X[:, 3] + 5 * X[:, 4] ** 5 + np.random.normal(0, 1))
+``` 
+После чего, задаются зависимости переменных `x11 x12 x13 x14` от переменных `x1 x2 x3 x4`.
+```python
+X[:, 10:] = X[:, :4] + np.random.normal(0, .025, (size, 4))
+``` 
+Первая группа переменных должна быть обозначена моделями как наименее значимая.
+
+#### Работа с моделями
+Первая модель `Ridge` - модель гребневой регрессии. 
+```python
+ridge = Ridge(alpha=1)
+ridge.fit(X, Y)
+```
+Данная модель не предоставляет прямого способа оценки важности признаков, так как она использует линейную комбинацию всех признаков с коэффициентами, которые оптимизируются во время обучения модели. Можно лишь оценить относительную важность признаков на основе абсолютных значений коэффициентов, которые были найдены в процессе обучения. Получить данные коэфициенты от модели можно с помощью метода `.coef_`.
+
+Вторая модель `RandomForestRegressor` - алгоритм ансамбля случайных деревьев решений. Он строит множество деревьев, каждое из которых обучается на случайной подвыборке данных и случайном подмножестве признаков.
+```python
+rfr = RandomForestRegressor()
+rfr.fit(X, Y)
+```
+Важность признаков в Random Forest Regressor определяется на основе того, как сильно каждый признак влияет на уменьшение неопределенности в предсказаниях модели. Для получения оценок важности в данной модели используется функция `.feature_importances_`.
+
+Третий инструмент `Recursive Feature Elimination – RFE` - алгоритм отбора признаков, который используется для оценки и ранжирования признаков по их важности.
+```python
+lr = LinearRegression()
+lr.fit(X, Y)
+rfe = RFE(lr)
+rfe.fit(X,Y)
+```
+Оценка важности признаков в RFE происходит путем анализа, как изменяется производительность модели при удалении каждого признака. В зависимости от этого, каждый признак получает ранг. Массив рангов признаков извлекается функцией `.ranking_`
+
+#### Нормализация оценок
+Модели `Ridge` и `RandomForestRegressor` рабботают по одинаковой логике вывода значимости оценок. В данных моделях оценки значимости параметров - веса значимости, которые они представляют для модели. Очевидно, что чем выше данный показатеь, тем более значимым является признак. Для нормализации оценок необходимо взять их по модулю и привести их к диапазону от 0 до 1.
+```python
+ranks = np.abs(ranks)
+minmax = MinMaxScaler()
+ranks = minmax.fit_transform(np.array(ranks).reshape(14, 1)).ravel()
+ranks = map(lambda x: round(x, 2), ranks)
+```
+Инструмент `Recursive Feature Elimination – RFE` работает иначе. Класс выдает не веса при коэффициентах регрессии, а именно ранг для каждого признака. Так наиболее важные признаки будут иметь ранг – "1", а менее важные признаки ранг больше "1". Коэффициенты остальных моделей тем важнее, чем больше их абсолютное значение. Для нормализации таких рангов от 0 до 1, необходимо просто взять обратное число от величины ранга признака.
+```python
+new_ranks = [float(1 / x) for x in ranks]
+new_ranks = map(lambda x: round(x, 2), new_ranks)
+```
+
+#### Оценка работы моделей
+Для оценки результатов выведем выявленные оценки значимости признаков каждой модели, а также средние оценки значимости признаков всех моделей.
+```
+Ridge
+[('x4', 1.0), ('x1', 0.98), ('x2', 0.8), ('x14', 0.61), ('x5', 0.54), ('x12', 0.39), ('x3', 0.25), ('x13', 0.19), ('x11', 0.16), ('x6', 0.08), ('x8', 0.07), ('x7', 0.02), ('x10', 0.02), ('x9', 0.0)]
+Recursive Feature Elimination
+[('x1', 1.0), ('x2', 1.0), ('x3', 1.0), ('x4', 1.0), ('x5', 1.0), ('x11', 1.0), ('x13', 1.0), ('x12', 0.5), ('x14', 0.33), ('x8', 0.25), ('x6', 0.2), ('x10', 0.17), ('x7', 0.14), ('x9', 0.12)]
+Random Forest Regression
+[('x14', 1.0), ('x2', 0.84), ('x4', 0.77), ('x1', 0.74), ('x11', 0.36), ('x12', 0.35), ('x5', 0.28), ('x3', 0.12), ('x13', 0.12), ('x6', 0.01), ('x7', 0.01), ('x8', 0.01), ('x9', 0.01), ('x10', 0.0)]
+Mean
+[('x4', 0.92), ('x1', 0.91), ('x2', 0.88), ('x14', 0.65), ('x5', 0.61), ('x11', 0.51), ('x3', 0.46), ('x13', 0.44), ('x12', 0.41), ('x8', 0.11), ('x6', 0.1), ('x7', 0.06), ('x10', 0.06), ('x9', 0.04)]
+
+```
+- Модель `Ridge` верно выявила значимость признаков `x1, x2, x4, х5`, но потеряла значимый признак `x3` и ошибочно включила признак `x14` в значимые.
+- Модель `RandomForestRegressor` также верно выявила значимость признаков `x1, x2, x4`, но потеряла значимые признаки `x3, х5` и ошибочно включила признак `x14` в значимые.
+- Инсрумент `Recursive Feature Elimination – RFE` безошибочно выделил все значимые признаки `x1, x2, х3, x4, x5`, но ошибочно отметил признаки `x11, x13` как значимые.
+- В среднем значимыми признаками были верно выявлены `x1, x2, x4, х5`, но значимый признак `x3` был потерян, а признаки `x11, х14` были признаны ошибочно значимыми.
+
+
+### Вывод
+Хужё всех показала себя модель `RandomForestRegressor`, потеряв два значимых признака и добавив один лишний. Модель `Ridge`и инструмент `Recursive Feature Elimination – RFE` допустили по одной ошибке, однако последний не потерял ни одного значимого признака. Значимость в среднем получилась неудовлетворительна и выдала три ошибки, как и первая модель. 
+
+Исходя из этого, можно сделать вывод, что для ранжирования признаков лучше использовать специально созданные для этого инструменты по типу `Recursive Feature Elimination – RFE`, а не использовать коэфициенты признаков регрессионных моделей.

arutunyan_dmitry_lab_2/main.py

@@ -0,0 +1,69 @@
+from operator import itemgetter
+import numpy as np
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.feature_selection import RFE
+from sklearn.linear_model import LinearRegression, Ridge
+from sklearn.preprocessing import MinMaxScaler
+
+
+np.random.seed(0)
+size = 750
+X = np.random.uniform(0, 1, (size, 14))                       # Генерируем исходные данные: 750 строк-наблюдений и 14 столбцов-признаков
+
+Y = (10 * np.sin(np.pi * X[:, 0] * X[:, 1]) + 20 * (X[:, 2] - .5) ** 2 +
+     10 * X[:, 3] + 5 * X[:, 4] ** 5 + np.random.normal(0, 1))     # Задаем функцию-выход: регрессионную проблему Фридмана
+
+X[:, 10:] = X[:, :4] + np.random.normal(0, .025, (size, 4))   # Добавляем зависимость признаков
+
+ridge = Ridge(alpha=1)            # Создаём модель гребневой регрессии и обучаем её
+ridge.fit(X, Y)
+
+lr = LinearRegression()           # Создаём модель линейной регрессии и обучаем её
+lr.fit(X, Y)
+rfe = RFE(lr)                     # На основе линейной модели выполняем рекурсивное сокращение признаков
+rfe.fit(X,Y)
+
+rfr = RandomForestRegressor()     # Создаём и обучаем регрессор случайного леса (используется вместо устаревшего рандомизированного лассо)
+rfr.fit(X, Y)
+
+
+def rank_ridge_rfr_to_dict(ranks, names):                                 # Метод нормализации оценок важности для модели гребневой регрессии и регрессора случайного леса
+    ranks = np.abs(ranks)
+    minmax = MinMaxScaler()
+    ranks = minmax.fit_transform(np.array(ranks).reshape(14, 1)).ravel()
+    ranks = map(lambda x: round(x, 2), ranks)
+    return dict(zip(names, ranks))
+
+
+def rank_rfe_to_dict(ranks, names):                                       # Метод нормализации оценок важности для модели рекурсивного сокращения признаков
+    new_ranks = [float(1 / x) for x in ranks]
+    new_ranks = map(lambda x: round(x, 2), new_ranks)
+    return dict(zip(names, new_ranks))
+
+
+if __name__ == '__main__':
+    names = ["x%s" % i for i in range(1, 15)]
+    ranks = dict()
+
+    ranks["Ridge"] = rank_ridge_rfr_to_dict(ridge.coef_, names)
+    ranks["Recursive Feature Elimination"] = rank_rfe_to_dict(rfe.ranking_, names)
+    ranks["Random Forest Regression"] = rank_ridge_rfr_to_dict(rfr.feature_importances_, names)
+
+    for key, value in ranks.items():                                          # Вывод нормализованных оценок важности признаков каждой модели
+        ranks[key] = sorted(value.items(), key=itemgetter(1), reverse=True)
+    for key, value in ranks.items():
+        print(key)
+        print(value)
+
+    mean = {}                                                                 # Нахождение средних значений оценок важности по 3м моделям
+    for key, value in ranks.items():
+        for item in value:
+            if item[0] not in mean:
+                mean[item[0]] = 0
+            mean[item[0]] += item[1]
+    for key, value in mean.items():
+        res = value / len(ranks)
+        mean[key] = round(res, 2)
+    mean = sorted(mean.items(), key=itemgetter(1), reverse=True)
+    print("Mean")
+    print(mean)

arutunyan_dmitry_lab_3/README.md

@@ -0,0 +1,170 @@
+
+## Лабораторная работа 3. Вариант 4.
+### Задание 
+Выполнить ранжирование признаков  и решить с помощью библиотечной реализации дерева решений 
+задачу классификации на 99% данных из курсовой работы. Проверить 
+работу модели на оставшемся проценте, сделать вывод.
+
+Модель:
+
+- Дерево решений `DecisionTreeClassifier`. 
+
+### Как запустить
+Для запуска программы необходимо с помощью командной строки в корневой директории файлов прокета прописать:
+```
+python main.py
+```
+После этого в папке `static` сгенерируются 2 графика, по которым оценивается результат выполнения программы.
+
+### Используемые технологии
+- Библиотека `numpy`, используемая для обработки массивов данных и вычислений
+- Библиотека `pyplot`, используемая для построения графиков.
+- Библиотека `pandas`, используемая для работы с данными для анализа scv формата.
+- Библиотека `sklearn` - большой набор функционала для анализа данных. Из неё были использованы инструменты:
+    - `DecisionTreeClassifier` - инструмент работы с моделью "Дерево решений"
+    - `metrics` - набор инструменов для оценки моделей
+    - `MinMaxScaler` - инструмент масштабирования значений в заданный диапазон
+
+### Описание работы
+#### Описание набора данных
+Набор данных - набор для определения возможности наличия ССЗ заболеваний у челоека
+
+Названия столбцов набора данных и их описание:
+
+ * HeartDisease - Имеет ли человек ССЗ (No / Yes),
+ * BMI - Индекс массы тела человека (float),
+ * Smoking - Выкурил ли человек хотя бы 5 пачек сигарет за всю жизнь (No / Yes),
+ * AlcoholDrinking - Сильно ли человек употребляет алкоголь (No / Yes),
+ * Stroke - Был ли у человека инсульт (No / Yes),
+ * PhysicalHealth - Сколько дней за последний месяц человек чувствовал себя плохо (0-30),
+ * MentalHealth - Сколько дней за последний месяц человек чувствовал себя удручённо (0-30),
+ * DiffWalking - Ииспытывает ли человек трудности при ходьбе (No / Yes),
+ * Sex - Пол (female, male),
+ * AgeCategory - Возрастная категория (18-24, 25-29, 30-34, 35-39, 40-44, 45-49, 50-54, 55-59, 60-64, 65-69, 70-74, 75-79, 80 or older),
+ * Race - Национальная принадлежность человека (White, Black, Hispanic, American Indian/Alaskan Native, Asian, Other),
+ * Diabetic - Был ли у человека диабет (No / Yes),
+ * PhysicalActivity - Занимался ли человек спротом за последний месяц (No / Yes),
+ * GenHealth - Общее самочувствие человека (Excellent, Very good, Good, Fair, Poor),
+ * SleepTime - Сколько человек в среднем спит за 24 часа (0-24),
+ * Asthma - Была ли у человека астма (No / Yes),
+ * KidneyDisease - Было ли у человека заболевание почек (No / Yes),
+ * SkinCancer - Был ли у человека рак кожи (No / Yes).
+
+Ссылка на страницу набора на kuggle: [Indicators of Heart Disease](https://www.kaggle.com/datasets/kamilpytlak/personal-key-indicators-of-heart-disease/data)
+
+#### Оцифровка и нормализация данных
+Для нормальной работы с данными, необходимо исключить из них все нечисловые значения. После этого, представить все строковые значения параметров как числовые и очистить датасет от "мусора". Для удаления нечисловых значений воспользуемся функцией `.dropna()`. Мы исключаем строки с нечисловыми значениями, поскольку данные предварительно были очищены (указано в описании датасета) и строк данных достаточно с избытком для обучение модели: `400.000`.
+
+После этого, переведём все строковые значения данных в числовые методами прямой оцифровки, разделения на группы, ранжирования.
+
+Процесс оцифровки данных столбцов со строковыми значениями:
+
+- Имеет ли человек ССЗ (0 / 1)
+- Выкурил ли человек хотя бы 5 пачек сигарет за всю жизнь (0 / 1)
+- Сильно ли человек употребляет алкоголь (0 / 1)
+- Был ли у человека инсульт (0 / 1)
+- Ииспытывает ли человек трудности при ходьбе (0 / 1)
+- Пол (Ж - 0 / М - 1)
+- Возрастная категория (средний возраст каждого диапазона)
+- Национальная принадлежность человека
+    - White - Европиойды - 0
+    - Black - Негройды - 1
+    - Hispanic - Испанцы - 2
+    - American Indian/Alaskan Native - Индусы - 3
+    - Asian - Азиаты - 4
+    - Other - Другие - 5
+- Был ли у человека диабет (0 / 1)
+- Занимался ли человек спротом за последний месяц (0 / 1)
+- Общее самочувствие человека
+    - Excellent - Отлично - 4
+    - Very good - Очень хорошо - 3
+    - Good - Хорошо - 2
+    - Fair - Нормально - 1
+    - "Poor" / "Other..." - Плохое или другое - 0
+- Была ли у человека астма (0 / 1)
+- Было ли у человека заболевание почек (0 /1)
+- Был ли у человека рак кожи (0 / 1)
+
+После оцифровки значений необходимо избавиться от строк с возможными остаточнымии данными ("мусором"). Для этого переведём автоматически все значения датасета в числовые функцией `to_numeric` и непереводимые отметим как `NaN` (параметр `errors='coerce'`). После снова сотрём строки содержащие нечисловые значения методом `.dropna()` и сохраним нормализованный датасет в новый csv файл:
+```python
+df = df.applymap(pd.to_numeric, errors='coerce').dropna()
+df.to_csv(fileout, index=False)
+```
+
+#### Выявление значимых параметров
+В выбранном датасете параметром предсказания `y` выступает столбец данных `HeartDisease`. Остальные столбцы считаются параметрами для решения задачи предсказания `x`, которые необходимо проранжировать по важности. Чтобы разделить выборку данных на обучаемую и тестовую, воспользуемся функцией `.iloc`. 
+```python
+x_train = df[["BMI", "Smoking", "AlcoholDrinking", "Stroke", "PhysicalHealth",
+            "MentalHealth", "DiffWalking", "Sex", "AgeCategory", "Race", "Diabetic",
+            "PhysicalActivity", "GenHealth", "SleepTime", "Asthma", "KidneyDisease", "SkinCancer"]].iloc[
+              0:round(len(df) / 100 * 99)]
+y_train = df["HeartDisease"].iloc[0:round(len(df) / 100 * 99)]
+x_test = df[["BMI", "Smoking", "AlcoholDrinking", "Stroke", "PhysicalHealth",
+            "MentalHealth", "DiffWalking", "Sex", "AgeCategory", "Race", "Diabetic",
+            "PhysicalActivity", "GenHealth", "SleepTime", "Asthma", "KidneyDisease", "SkinCancer"]].iloc[
+              round(len(df) / 100 * 99):len(df)]
+y_test = df["HeartDisease"].iloc[round(len(df) / 100 * 99):len(df)]
+```
+Где `round(len(df) / 100 * 99)` - 99ти процентная строка в датасете.
+
+Теперь, обучим модель на данных `x_train` и `y_train` и получим значимость каждого признака в модели с помощью метода `.feature_importances_`. После отмасштабируем значения важности признаков.
+```python
+ranks = np.abs(dtc.feature_importances_)
+minmax = MinMaxScaler()
+ranks = minmax.fit_transform(np.array(ranks).reshape(len(x_train.columns), 1)).ravel()
+ranks = map(lambda x: round(x, 2), ranks)
+ranks = dict(zip(x_train.columns, ranks))
+ranks = dict(sorted(ranks.items(), key=lambda x: x[1], reverse=True))
+```
+
+Чтобы отсеять значимые параметры от незначимых, условимся, что параметры, с оценкой значимости меньше `0.05` будут считаться незначимыми. Выведем список параметров с пометками:
+```
+X ranging results: 
+ * BMI: 1.0 - Approved
+ * SleepTime: 0.26 - Approved
+ * PhysicalHealth: 0.18 - Approved
+ * GenHealth: 0.16 - Approved
+ * MentalHealth: 0.15 - Approved
+ * AgeCategory: 0.14 - Approved
+ * Race: 0.07 - Approved
+ * PhysicalActivity: 0.06 - Approved
+ * Stroke: 0.04 - Eliminated
+ * Smoking: 0.03 - Eliminated
+ * Asthma: 0.03 - Eliminated
+ * SkinCancer: 0.03 - Eliminated
+ * DiffWalking: 0.02 - Eliminated
+ * Sex: 0.02 - Eliminated
+ * AlcoholDrinking: 0.0 - Eliminated
+ * Diabetic: 0.0 - Eliminated
+ * KidneyDisease: 0.0 - Eliminated
+```
+
+Где `Approved` - параметр значим и будет использоваться в предсказании, а `Eliminated` - параметр незначим и будет исключён.
+
+#### Решение задачи кластеризации на полном наборе признаков 
+Чтобы решить задачу кластеризации моделью `DecisionTreeClassifier`, воспользуемся методом `.predict()`. Оценку качества решения и графики будем строить теми же методами, что в 1й лабораторной работе.
+
+График решения задачи классификации на полном наборе признаков:
+
+![](FullParam.png "")
+
+#### Решение задачи кластеризации, используя только значимые признаки
+Согласно предыдущему пункту, значимыми признаками модели были выявлены:
+ * BMI
+ * SleepTime
+ * PhysicalHealth
+ * GenHealth
+ * MentalHealth
+ * AgeCategory
+ * Race
+ * PhysicalActivity
+Обучим модель только с их использованием, решим задачу классификации и построим график.
+
+График решения задачи классификации, используя только значимые признаки:
+
+![](ImpParam.png "")
+
+### Вывод
+Согласно среднеквадратической ошибке и коэфициенту детерминации, модель, обученная только на значимых признаков отработала точнее, чем модель, обученная на полном наборе признаков. Это значит, что ранжирование было проведено верно и дало полезный результат. О логической оценке исключённых данных сказать ничего не получится, поскольку действительную зависимость результата от параметров значет только медицинский эксперт.
+
+Исходя их общих значений точности, обе модели показали хорошие результаты и могут быть применимы к решению задачи классификации на данном наборе данных.

arutunyan_dmitry_lab_3/main.py

@@ -0,0 +1,221 @@
+import pandas as pd
+import numpy as np
+from matplotlib import pyplot as plt
+from sklearn import metrics
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.tree import DecisionTreeClassifier
+
+'''
+Названия столбцов набора данных и их описание:
+
+ * HeartDisease - Имеет ли человек ССЗ (No / Yes),
+ * BMI - Индекс массы тела человека (float),
+ * Smoking - Выкурил ли человек хотя бы 5 пачек сигарет за всю жизнь (No / Yes),
+ * AlcoholDrinking - Сильно ли человек употребляет алкоголь (No / Yes),
+ * Stroke - Был ли у человека инсульт (No / Yes),
+ * PhysicalHealth - Сколько дней за последний месяц человек чувствовал себя плохо (0-30),
+ * MentalHealth - Сколько дней за последний месяц человек чувствовал себя удручённо (0-30),
+ * DiffWalking - Ииспытывает ли человек трудности при ходьбе (No / Yes),
+ * Sex - Пол (female, male),
+ * AgeCategory - Возрастная категория (18-24, 25-29, 30-34, 35-39, 40-44, 45-49, 50-54, 55-59, 60-64, 65-69, 70-74, 75-79, 80 or older),
+ * Race - Национальная принадлежность человека (White, Black, Hispanic, American Indian/Alaskan Native, Asian, Other),
+ * Diabetic - Был ли у человека диабет (No / Yes),
+ * PhysicalActivity - Занимался ли человек спротом за последний месяц (No / Yes),
+ * GenHealth - Общее самочувствие человека (Excellent, Very good, Good, Fair, Poor),
+ * SleepTime - Сколько человек в среднем спит за 24 часа (0-24),
+ * Asthma - Была ли у человека астма (No / Yes),
+ * KidneyDisease - Было ли у человека заболевание почек (No / Yes),
+ * SkinCancer - Был ли у человека рак кожи (No / Yes).
+'''
+
+
+# Метод оцифровки и нормализации данных
+def normalisation(filename):
+    fileout = "P:\\ULSTU\\ИИС\\Datasets\\heart_2020_norm.csv"
+    df = pd.read_csv(filename, sep=',').dropna()              # Считываем данные с csv файла и удаляем строки, содержащие NaN
+
+    for index, row in df.iterrows():
+        if index % 10000 == 0:
+            print("normalisation running . . .  " + str(round((index / len(df) * 100), 2)) +'%')
+        if "Yes" in row["HeartDisease"]:                       # Имеет ли человек ССЗ (0 / 1)
+            df.at[index, "HeartDisease"] = 1
+        else:
+            df.at[index, "HeartDisease"] = 0
+        if "Yes" in row["Smoking"]:                            # Выкурил ли человек хотя бы 5 пачек сигарет за всю жизнь (0 / 1)
+            df.at[index, "Smoking"] = 1
+        else:
+            df.at[index, "Smoking"] = 0
+        if "Yes" in row["AlcoholDrinking"]:                    # Сильно ли человек употребляет алкоголь (0 / 1)
+            df.at[index, "AlcoholDrinking"] = 1
+        else:
+            df.at[index, "AlcoholDrinking"] = 0
+        if "Yes" in row["Stroke"]:                             # Был ли у человека инсульт (0 / 1)
+            df.at[index, "Stroke"] = 1
+        else:
+            df.at[index, "Stroke"] = 0
+        if "Yes" in row["DiffWalking"]:                        # Ииспытывает ли человек трудности при ходьбе (0 / 1)
+            df.at[index, "DiffWalking"] = 1
+        else:
+            df.at[index, "DiffWalking"] = 0
+        if "Female" in row["Sex"]:                             # Пол (Ж - 0 / М - 1)
+            df.at[index, "Sex"] = 0
+        else:
+            df.at[index, "Sex"] = 1
+        if "18-24" in row["AgeCategory"]:                      # Возрастная категория (средний возраст каждого диапазона)
+            df.at[index, "AgeCategory"] = (18 + 24) / 2
+        elif "25-29" in row["AgeCategory"]:
+            df.at[index, "AgeCategory"] = (25 + 29) / 2
+        elif "30-34" in row["AgeCategory"]:
+            df.at[index, "AgeCategory"] = (30 + 34) / 2
+        elif "35-39" in row["AgeCategory"]:
+            df.at[index, "AgeCategory"] = (35 + 39) / 2
+        elif "40-44" in row["AgeCategory"]:
+            df.at[index, "AgeCategory"] = (40 + 44) / 2
+        elif "45-49" in row["AgeCategory"]:
+            df.at[index, "AgeCategory"] = (45 + 49) / 2
+        elif "50-54" in row["AgeCategory"]:
+            df.at[index, "AgeCategory"] = (50 + 54) / 2
+        elif "55-59" in row["AgeCategory"]:
+            df.at[index, "AgeCategory"] = (55 + 59) / 2
+        elif "60-64" in row["AgeCategory"]:
+            df.at[index, "AgeCategory"] = (60 + 64) / 2
+        elif "65-69" in row["AgeCategory"]:
+            df.at[index, "AgeCategory"] = (65 + 69) / 2
+        elif "70-74" in row["AgeCategory"]:
+            df.at[index, "AgeCategory"] = (70 + 74) / 2
+        elif "75-79" in row["AgeCategory"]:
+            df.at[index, "AgeCategory"] = (75 + 79) / 2
+        else:
+            df.at[index, "AgeCategory"] = (25 + 29) / 2
+        if "White" in row["Race"]:                               # Национальная принадлежность человека
+            df.at[index, "Race"] = 0                             # White - Европиойды - 0
+        elif "Black" in row["Race"]:                             # Black - Негройды - 1
+            df.at[index, "Race"] = 1                             # Hispanic - Испанцы - 2
+        elif "Hispanic" in row["Race"]:                          # American Indian/Alaskan Native - Индусы - 3
+            df.at[index, "Race"] = 2                             # Asian - Азиаты - 4
+        elif "American Indian/Alaskan Native" in row["Race"]:    # Other - Другие - 5
+            df.at[index, "Race"] = 3
+        elif "Asian" in row["Race"]:
+            df.at[index, "Race"] = 4
+        else:
+            df.at[index, "Race"] = 5
+        if "Yes" in row["Diabetic"]:                            # Был ли у человека диабет (0 / 1)
+            df.at[index, "Diabetic"] = 1
+        else:
+            df.at[index, "Diabetic"] = 0
+        if "Yes" in row["PhysicalActivity"]:                     # Занимался ли человек спротом за последний месяц (0 / 1)
+            df.at[index, "PhysicalActivity"] = 1
+        else:
+            df.at[index, "PhysicalActivity"] = 0
+        if "Excellent" in row["GenHealth"]:                      # Общее самочувствие человека
+            df.at[index, "GenHealth"] = 4                        # Excellent - Отлично - 4
+        elif "Very good" in row["GenHealth"]:                    # Very good - Очень хорошо - 3
+            df.at[index, "GenHealth"] = 3                        # Good - Хорошо - 2
+        elif "Good" in row["GenHealth"]:                         # Fair - Нормально - 1
+            df.at[index, "GenHealth"] = 2                        # "Poor" / "Other..." - Плохое или другое - 0
+        elif "Fair" in row["GenHealth"]:
+            df.at[index, "GenHealth"] = 1
+        else:
+            df.at[index, "GenHealth"] = 0
+        if "Yes" in row["Asthma"]:                               # Была ли у человека астма (0 / 1)
+            df.at[index, "Asthma"] = 1
+        else:
+            df.at[index, "Asthma"] = 0
+        if "Yes" in row["KidneyDisease"]:                        # Было ли у человека заболевание почек (0 /1)
+            df.at[index, "KidneyDisease"] = 1
+        else:
+            df.at[index, "KidneyDisease"] = 0
+        if "Yes" in row["SkinCancer"]:                           # Был ли у человека рак кожи (0 / 1)
+            df.at[index, "SkinCancer"] = 1
+        else:
+            df.at[index, "SkinCancer"] = 0
+
+    df = df.applymap(pd.to_numeric, errors='coerce').dropna()    # Гарантированно убираем все нечисловые значения из датасета
+    df.to_csv(fileout, index=False)                              # Сохраняем нормализованный датасет для дальнейшей работы
+    return fileout
+
+
+# Метод ранжирования параметров по степени важности
+def param_range(filename, elim_kp):
+    df = pd.read_csv(filename, sep=',')        # Считываем нормализованные данные и разделяем их на выборки
+    x_train = df[["BMI", "Smoking", "AlcoholDrinking", "Stroke", "PhysicalHealth",
+            "MentalHealth", "DiffWalking", "Sex", "AgeCategory", "Race", "Diabetic",
+            "PhysicalActivity", "GenHealth", "SleepTime", "Asthma", "KidneyDisease", "SkinCancer"]].iloc[
+              0:round(len(df) / 100 * 99)]
+    y_train = df["HeartDisease"].iloc[0:round(len(df) / 100 * 99)]
+    x_test = df[["BMI", "Smoking", "AlcoholDrinking", "Stroke", "PhysicalHealth",
+                  "MentalHealth", "DiffWalking", "Sex", "AgeCategory", "Race", "Diabetic",
+                  "PhysicalActivity", "GenHealth", "SleepTime", "Asthma", "KidneyDisease", "SkinCancer"]].iloc[
+              round(len(df) / 100 * 99):len(df)]
+    y_test = df["HeartDisease"].iloc[round(len(df) / 100 * 99):len(df)]
+
+    dtc = DecisionTreeClassifier(random_state=241)                                     # Создаём модель дерева решений
+    dtc.fit(x_train.values, y_train.values)                                            # Обучаем модель на данных
+    y_predict = dtc.predict(x_test.values)                                             # Решаем задачу классификации на полном наборе признаков
+    err = pred_errors(y_predict, y_test.values)                                        # Рассчитываем ошибки предсказания
+    make_plots(y_test.values, y_predict, err[0], err[1], "Полный набор данных")    # Строим графики
+
+    ranks = np.abs(dtc.feature_importances_)                                                 # Получаем значимость каждого признака в модели
+    minmax = MinMaxScaler()                                                                  # Шкалируем и нормализуем значимость
+    ranks = minmax.fit_transform(np.array(ranks).reshape(len(x_train.columns), 1)).ravel()
+    ranks = map(lambda x: round(x, 2), ranks)
+    ranks = dict(zip(x_train.columns, ranks))
+    ranks = dict(sorted(ranks.items(), key=lambda x: x[1], reverse=True))                    # Сортируем оценки по максимуму и записываем в словарь
+
+    print("X ranging results: \n")
+    del_keys = []                                                    # Исключаем параметры, важность которых меньше elim_kp
+    for key, value in ranks.items():
+        if value >= elim_kp:
+            print(" * " + key + ": " + str(value) + " - Approved")
+        else:
+            print(" * " + key + ": " + str(value) + " - Eliminated")
+            del_keys.append(key)
+
+    for key in del_keys:
+        ranks.pop(key)
+
+    return filename, ranks.keys()
+
+
+# Метод решения задачи классификации, основанный только на значимых параметрах
+def most_valuable_prediction(params):
+    filename = params[0]
+    val_p = params[1]
+    df = pd.read_csv(filename, sep=',')
+    x_train = df[val_p].iloc[0:round(len(df) / 100 * 99)]
+    y_train = df["HeartDisease"].iloc[0:round(len(df) / 100 * 99)]
+    x_test = df[val_p].iloc[round(len(df) / 100 * 99):len(df)]
+    y_test = df["HeartDisease"].iloc[round(len(df) / 100 * 99):len(df)]
+
+    dtc = DecisionTreeClassifier(random_state=241)
+    dtc.fit(x_train.values, y_train.values)
+    y_predict = dtc.predict(x_test.values)
+    err = pred_errors(y_predict, y_test.values)
+    make_plots(y_test.values, y_predict, err[0], err[1], "Только важные параметры")
+
+
+# Метод рассчёта ошибок
+def pred_errors(y_predict, y_test):
+    mid_square = np.round(np.sqrt(metrics.mean_squared_error(y_test, y_predict)),3)            # Рассчёт среднеквадратичной ошибки модели
+    det_kp = np.round(metrics.accuracy_score (y_test, y_predict), 2)                           # Рассчёт коэфициента детерминации модели
+    return mid_square, det_kp
+
+
+# Метод отрисовки графиков
+def make_plots(y_test, y_predict, mid_sqrt, det_kp, title):
+        plt.plot(y_test, c="red", label="\"y\" исходная")                                # Создание графика исходной функции
+        plt.plot(y_predict, c="green", label="\"y\" предсказанная \n"
+                                                  "Ср^2 = " + str(mid_sqrt) + "\n"
+                                                  "Кд = " + str(det_kp))                       # Создание графика предсказанной функции
+        plt.legend(loc='lower left')
+        plt.title(title)
+        plt.savefig('static/' + title + '.png')
+        plt.close()
+
+
+if __name__ == '__main__':
+    # Работа системы в комплексе
+    # Здесь elim_kp - значение пороговой значимости параметра (выбран эмпирически)
+    most_valuable_prediction(param_range(normalisation("P:\\ULSTU\\ИИС\\Datasets\\heart_2020_cleaned.csv"), 0.05))
+
+

arutunyan_dmitry_lab_4/README.md

@@ -0,0 +1,131 @@
+
+## Лабораторная работа 4. Вариант 4.
+### Задание 
+Использовать метод кластеризации по варианту для данных из курсовой работы. Самостоятельно сформулировав задачу. Интерпретировать результаты и оценить, насколько хорошо он подходит для 
+решения сформулированной задачи.
+
+Алгоритм кластеризации:
+
+- Пространственная кластеризация данных с шумом на основе плотности `DBSCAN`. 
+
+### Как запустить
+Для запуска программы необходимо с помощью командной строки в корневой директории файлов прокета прописать:
+```
+python main.py
+```
+После этого в папке `static` сгенерируются 3 графика, по которым оценивается результат выполнения программы.
+
+### Используемые технологии
+- Библиотека `numpy`, используемая для обработки массивов данных и вычислений
+- Библиотека `pyplot`, используемая для построения графиков.
+- Библиотека `pandas`, используемая для работы с данными для анализа scv формата.
+- Библиотека `sklearn` - большой набор функционала для анализа данных. Из неё были использованы инструменты:
+    - `DBSCAN` - инструмент работы с моделью "Пространственная кластеризация данных с шумом на основе плотности"
+    - `metrics` - набор инструменов для оценки моделей
+    - `LinearRegression` - инструмент работы с моделью "Линейная регрессия"
+
+`DBSCAN` - это алгоритм кластеризации, который используется для кластеризации данных на основе плотности, что позволяет обнаруживать кластеры произвольной формы и обнаруживать выбросы (шум). `DBSCAN` может быть полезным при предварительной обработке данных перед задачей предсказания:
+ - Удаление выбросов (шума): `DBSCAN` может помочь в идентификации и удалении выбросов из данных. 
+ - Генерация новых признаков: `DBSCAN` может быть использован для генерации новых признаков на основе кластеров.
+
+### Описание работы
+#### Описание набора данных
+Набор данных - набор для определения возможности наличия ССЗ заболеваний у челоека
+
+Названия столбцов набора данных и их описание:
+
+ * HeartDisease - Имеет ли человек ССЗ (No / Yes),
+ * BMI - Индекс массы тела человека (float),
+ * Smoking - Выкурил ли человек хотя бы 5 пачек сигарет за всю жизнь (No / Yes),
+ * AlcoholDrinking - Сильно ли человек употребляет алкоголь (No / Yes),
+ * Stroke - Был ли у человека инсульт (No / Yes),
+ * PhysicalHealth - Сколько дней за последний месяц человек чувствовал себя плохо (0-30),
+ * MentalHealth - Сколько дней за последний месяц человек чувствовал себя удручённо (0-30),
+ * DiffWalking - Ииспытывает ли человек трудности при ходьбе (No / Yes),
+ * Sex - Пол (female, male),
+ * AgeCategory - Возрастная категория (18-24, 25-29, 30-34, 35-39, 40-44, 45-49, 50-54, 55-59, 60-64, 65-69, 70-74, 75-79, 80 or older),
+ * Race - Национальная принадлежность человека (White, Black, Hispanic, American Indian/Alaskan Native, Asian, Other),
+ * Diabetic - Был ли у человека диабет (No / Yes),
+ * PhysicalActivity - Занимался ли человек спротом за последний месяц (No / Yes),
+ * GenHealth - Общее самочувствие человека (Excellent, Very good, Good, Fair, Poor),
+ * SleepTime - Сколько человек в среднем спит за 24 часа (0-24),
+ * Asthma - Была ли у человека астма (No / Yes),
+ * KidneyDisease - Было ли у человека заболевание почек (No / Yes),
+ * SkinCancer - Был ли у человека рак кожи (No / Yes).
+
+Ссылка на страницу набора на kuggle: [Indicators of Heart Disease](https://www.kaggle.com/datasets/kamilpytlak/personal-key-indicators-of-heart-disease/data)
+
+#### Формулировка задачи
+Согласно прописанным в литературе варантам использования, `DBSCAN` может помочь в идентификации и удалении выбросов из данных, а также может быть использован для генерации новых признаков на основе кластеров. Исходя из этого сформулируем задачу:
+> "В наборе данных с помощью `DBSCAN` определить и исключить строки содержащие шум, а также сгенерировать новый признак для данных на сонове кластеров. Проверить результат через решение задачи предсказания моделью линейной регрессии на исходных и модифицированных данных"
+
+#### Использование алгоритма `DBSCAN`
+Чтобы эффективно использовать алгоритм `DBSCAN` необходимо правильно определить два параметра: `eps` - радиус окрестности вокруг каждой точки и `min_samples` - минимальное количество точек, которые должны находиться в окрестности, чтобы рассматривать ее как ядро кластера.
+
+Начнём с получения датасета из csv файла и признаков кластеризации:
+```python
+df = pd.read_csv(filein, sep=',').iloc[0:10000]
+x = df.drop("HeartDisease", axis=1)
+```
+> **Warning**
+>
+> Алгоритм `DBSCAN` - очень жадная по памяти программа. В худшем случае алгоритм может занимать Q(N^2) оперативной памяти устройства, поэтому исследование получится провести лишь на частичной выборке в 10000 строк данных.
+
+Для нахождения оптимального значения параметра `eps` воспользуемся методом рассчёта средней плотности данных. Для этого необходимо найти суммы максимальных и минимальных значений каждого признака и взять среднее арифметическое этих двух значений:
+
+```python
+eps_opt = (x.max().values.mean() + x.min().values.mean()) / 2
+```
+Оптимальное значение параметра `min_samples` будем искать эмпирически. Условимся, что нам будет достаточно разделить высе данные на 6 кластеров (пусть это будут степени риска возникновения ССЗ), но нам нельзя терять в качестве выбросов более 10% данных. Тогда мы будем варьировать параметр `min_samples` от 1 до кол-ва всех данных и закончим эксперимент при выполнении одного из указанных условий:
+
+```python
+developed_data = []
+    for i in range(len(x)):
+        if i == 0:
+            continue
+        dbscan = DBSCAN(eps=eps_opt, min_samples=i) 
+        clusters = dbscan.fit_predict(x.values)
+        if len(set(clusters)) <= 7:
+            developed_data = clusters
+            break
+        if list(clusters).count(-1) / len(clusters) >= 0.1:
+            developed_data = clusters
+            break
+```
+
+Таким образом в массиве `developed_data` мы получим значение кластеров для каждй строки датасета. Добавим её как дополнительный признак.
+
+График кластеров для значений датасета:
+
+![](dbscan.png "")
+
+#### Решение задачи предсказания
+Создадим два обучающих модуля. В 1м удалим все строки с кластером `-1`, что указывает на то, что они шум и воспользуемся дополнительным признаком `DBSCAN`:
+```python
+df_mod = df.loc[df["DBSCAN"] != -1]
+x_train_mod = df_mod.drop("HeartDisease", axis=1).iloc[0:round(len(df) / 100 * 99)]
+y_train_mod = df_mod["HeartDisease"].iloc[0:round(len(df) / 100 * 99)]
+x_test_mod = df_mod.drop("HeartDisease", axis=1).iloc[round(len(df) / 100 * 99):len(df)]
+y_test_mod = df_mod["HeartDisease"].iloc[round(len(df) / 100 * 99):len(df)]
+```
+Во 2м модуле для разделения на выборки оставим исходные данные:
+```python
+x_train = df.drop(["HeartDisease", "DBSCAN"], axis=1).iloc[0:round(len(df) / 100 * 99)]
+y_train = df["HeartDisease"].iloc[0:round(len(df) / 100 * 99)]
+x_test = df.drop(["HeartDisease", "DBSCAN"], axis=1).iloc[round(len(df) / 100 * 99):len(df)]
+y_test = df["HeartDisease"].iloc[round(len(df) / 100 * 99):len(df)]
+``` 
+Создаим две модели регрессии и на каждой решим задачу предсказания. Вычислим ошибки и построим графики.
+
+График решения задачи предсказания на модифицированных данных:
+
+![](regdbscan.png "")
+
+График решения задачи предсказания на исходных данных:
+
+![](reg.png "")
+
+### Вывод
+Согласно графиком, модель, обученная на исходных данных показала результат лучше, чем модель, обученная на модифицированных данных. Получается, что на данном наборе, используя алгоритм `DBSCAN`, мы не только невероятно увеличиваем затратность памяти на обучение модели, но и отрицательно влияем на результат её работы. Это означает, что использование алгоритма на таком наборе данных абсолютно нецелесообразно. 
+
+Связанно это может быть с большим количеством бинарных признаков в данных. В таких случаях задачи кластеризации решаются сравнительно хуже.

arutunyan_dmitry_lab_4/main.py

@@ -0,0 +1,96 @@
+import pandas as pd
+import numpy as np
+from matplotlib import pyplot as plt
+from sklearn import metrics
+from sklearn.cluster import DBSCAN
+from sklearn.linear_model import LinearRegression
+
+filein = "P:\\ULSTU\\ИИС\\Datasets\\heart_2020_norm.csv"
+fileout = "P:\\ULSTU\\ИИС\\Datasets\\heart_2020_classified.csv"
+
+
+# Метод устранения шумов и кластеризации данных алгоритмом DBSCAN
+def dbscan():
+    df = pd.read_csv(filein, sep=',').iloc[0:10000]                  # Считывание датасета
+    x = df.drop("HeartDisease", axis=1)                              # Определение кластеризуемых параметров
+
+    eps_opt = (x.max().values.mean() + x.min().values.mean()) / 2    # Рассчёт опционального радиуса окрестности методом средней плотности
+
+    developed_data = []                                              # Подбор значения минимального количества точек в окрестности
+    for i in range(len(x)):                                          # - Начинаем с одной точки
+        if i == 0:
+            continue                                                 # - Увеличиваем значение кол-ва точек на 1
+        dbscan = DBSCAN(eps=eps_opt, min_samples=i)                  # - Обучаем модель и получаем массив кластеров
+        clusters = dbscan.fit_predict(x.values)
+        if len(set(clusters)) <= 7:                                  # - Прекращаем увеличивать значение точек, если кол-во кластеров уменьшилось до требуемого
+            developed_data = clusters
+            break
+        if list(clusters).count(-1) / len(clusters) >= 0.1:          # - Или если "шум" превышает 10% от данных
+            developed_data = clusters
+            break
+
+    make_plot(x, developed_data)
+    df["DBSCAN"] = developed_data
+    df.to_csv(fileout, index=False)                                  # Сохраняем полученные кластеры как доп. столбец датасета
+
+
+# Метод оценки эффективности кластеризации DBSCAN
+def linear_reg():                                           # Создаём две выборки данных
+    df = pd.read_csv(fileout, sep=',')                      # В 1й избавляемся от "шумов" и используем столбец кластеров как признак
+    df_mod = df.loc[df["DBSCAN"] != -1]
+    x_train_mod = df_mod.drop("HeartDisease", axis=1).iloc[0:round(len(df) / 100 * 99)]
+    y_train_mod = df_mod["HeartDisease"].iloc[0:round(len(df) / 100 * 99)]
+    x_test_mod = df_mod.drop("HeartDisease", axis=1).iloc[round(len(df) / 100 * 99):len(df)]
+    y_test_mod = df_mod["HeartDisease"].iloc[round(len(df) / 100 * 99):len(df)]
+                                                            # Во 2й оставляем обычные данные
+    x_train = df.drop(["HeartDisease", "DBSCAN"], axis=1).iloc[0:round(len(df) / 100 * 99)]
+    y_train = df["HeartDisease"].iloc[0:round(len(df) / 100 * 99)]
+    x_test = df.drop(["HeartDisease", "DBSCAN"], axis=1).iloc[round(len(df) / 100 * 99):len(df)]
+    y_test = df["HeartDisease"].iloc[round(len(df) / 100 * 99):len(df)]
+
+    lr_mod = LinearRegression()                              # Обучаем модель без "шума" и с признаком кластеров
+    lr_mod.fit(x_train_mod.values, y_train_mod.values)
+    y_mod_pred = lr_mod.predict(x_test_mod.values)
+    err = pred_errors(y_mod_pred, y_test_mod.values)
+    make_plots(y_test_mod.values, y_mod_pred, err[0], err[1], "Регрессия с кластеризацией dbscan")
+
+    lr = LinearRegression()                                  # Обучаем модель на исходных данных
+    lr.fit(x_train.values, y_train.values)
+    y_pred = lr.predict(x_test.values)
+    err = pred_errors(y_pred, y_test.values)
+    make_plots(y_test.values, y_pred, err[0], err[1], "Чистая линейная регрессия")
+
+
+# Метод рассчёта ошибок
+def pred_errors(y_predict, y_test):
+    mid_square = np.round(np.sqrt(metrics.mean_squared_error(y_test, y_predict)),3)            # Рассчёт среднеквадратичной ошибки модели
+    det_kp = np.round(metrics.r2_score (y_test, y_predict), 2)                                 # Рассчёт коэфициента детерминации модели
+    return mid_square, det_kp
+
+
+# Метод отрисовки графиков
+def make_plots(y_test, y_predict, mid_sqrt, det_kp, title):
+        plt.plot(y_test, c="red", label="\"y\" исходная")                                # Создание графика исходной функции
+        plt.plot(y_predict, c="green", label="\"y\" предсказанная \n"
+                                                  "Ср^2 = " + str(mid_sqrt) + "\n"
+                                                  "Кд = " + str(det_kp))                       # Создание графика предсказанной функции
+        plt.legend(loc='lower left')
+        plt.title(title)
+        plt.savefig('static/' + title + '.png')
+        plt.close()
+
+
+# Метод построения графика кластеризации
+def make_plot(x, c):
+    plt.scatter(x.values[:, 0], x.values[:, 13], c=c, cmap='viridis')
+    plt.xlabel('BMI')
+    plt.ylabel('SleepTime')
+    plt.colorbar()
+    plt.title('DBSCAN Clustering')
+    plt.savefig('static/dbscan.png')
+    plt.close()
+
+
+if __name__ == '__main__':
+    dbscan()
+    linear_reg()

arutunyan_dmitry_lab_5/README.md

@@ -0,0 +1,94 @@
+
+## Лабораторная работа 5. Вариант 4.
+### Задание 
+Использовать регрессию по варианту для данных из курсовой работы. Самостоятельно сформулировав задачу. Интерпретировать результаты и оценить, насколько хорошо он подходит для 
+решения сформулированной задачи.
+
+Модель регрессии:
+
+- Гребневая регрессия `Ridge`. 
+
+### Как запустить
+Для запуска программы необходимо с помощью командной строки в корневой директории файлов прокета прописать:
+```
+python main.py
+```
+После этого в папке `static` сгенерируются 2 графика, по которым оценивается результат выполнения программы.
+
+### Используемые технологии
+- Библиотека `numpy`, используемая для обработки массивов данных и вычислений
+- Библиотека `pyplot`, используемая для построения графиков.
+- Библиотека `pandas`, используемая для работы с данными для анализа scv формата.
+- Библиотека `sklearn` - большой набор функционала для анализа данных. Из неё были использованы инструменты:
+    - `Ridge` - инструмент работы с моделью "Гребневая регрессия"
+    - `metrics` - набор инструменов для оценки моделей
+
+`Ridge` - это линейная регрессионная модель с регуляризацией L2, которая может быть использована для решения задачи регрессии.
+
+### Описание работы
+#### Описание набора данных
+Набор данных - набор для определения возможности наличия ССЗ заболеваний у челоека
+
+Названия столбцов набора данных и их описание:
+
+ * HeartDisease - Имеет ли человек ССЗ (No / Yes),
+ * BMI - Индекс массы тела человека (float),
+ * Smoking - Выкурил ли человек хотя бы 5 пачек сигарет за всю жизнь (No / Yes),
+ * AlcoholDrinking - Сильно ли человек употребляет алкоголь (No / Yes),
+ * Stroke - Был ли у человека инсульт (No / Yes),
+ * PhysicalHealth - Сколько дней за последний месяц человек чувствовал себя плохо (0-30),
+ * MentalHealth - Сколько дней за последний месяц человек чувствовал себя удручённо (0-30),
+ * DiffWalking - Ииспытывает ли человек трудности при ходьбе (No / Yes),
+ * Sex - Пол (female, male),
+ * AgeCategory - Возрастная категория (18-24, 25-29, 30-34, 35-39, 40-44, 45-49, 50-54, 55-59, 60-64, 65-69, 70-74, 75-79, 80 or older),
+ * Race - Национальная принадлежность человека (White, Black, Hispanic, American Indian/Alaskan Native, Asian, Other),
+ * Diabetic - Был ли у человека диабет (No / Yes),
+ * PhysicalActivity - Занимался ли человек спротом за последний месяц (No / Yes),
+ * GenHealth - Общее самочувствие человека (Excellent, Very good, Good, Fair, Poor),
+ * SleepTime - Сколько человек в среднем спит за 24 часа (0-24),
+ * Asthma - Была ли у человека астма (No / Yes),
+ * KidneyDisease - Было ли у человека заболевание почек (No / Yes),
+ * SkinCancer - Был ли у человека рак кожи (No / Yes).
+
+Ссылка на страницу набора на kuggle: [Indicators of Heart Disease](https://www.kaggle.com/datasets/kamilpytlak/personal-key-indicators-of-heart-disease/data)
+
+#### Формулировка задачи
+Поскольку модель гребневой регрессии используется для решения задачи регресси, то попробуем на ней предсказать поведение параметров при обучении на всех признаках, и на значимых признаках, найденных ранее в лабораторной №3. Сформулируем задачу:
+> "Решить задачу предсказания с помощью моделей гребневой регрессии, обученных на всех признаках и только на значимых признаках. Сравнить результаты работы моделей"
+
+#### Решение задачи предсказания
+
+Создадим два обучающих модуля. В 1й включим все признаки. Разделим даныые на выборки. Пусть обучающая выборка будет 99% данных, а тестовая - 1% соответсвенно:
+```python
+x_train = df.drop("HeartDisease", axis=1).iloc[0:round(len(df) / 100 * 99)]
+y_train = df["HeartDisease"].iloc[0:round(len(df) / 100 * 99)]
+x_test = df.drop("HeartDisease", axis=1).iloc[round(len(df) / 100 * 99):len(df)]
+y_test = df["HeartDisease"].iloc[round(len(df) / 100 * 99):len(df)]
+```
+Тогда во 2м модуле используем только признаки, названные значимыми в 3й лабораторной, а именно:
+ * BMI
+ * SleepTime
+ * PhysicalHealth
+ * GenHealth
+ * MentalHealth
+ * AgeCategory
+ * Race
+ * PhysicalActivity
+
+Обучим две модели гребневой регнессии на данных из разных модулей. Решим задачу предсказания, найдём ошибки и построим графики.
+
+График решения задачи предсказания моделью гребневой регрессии с использованием всех признаков:
+
+![](all.png "")
+
+График решения задачи предсказания моделью гребневой регрессии с использованием значимых признаков:
+
+![](imp.png "")
+
+### Вывод
+Согласно графиком, среднеквадратическая ошибка обеих моделей достаточна низкая. что свидетельствует достаточно точному соответствию истиных и полученных значений, однако коэффициент детерминации моделей имеет очень низкое значение, что свидетельствует практически полному непониманию модели зависимостей в данных.
+> **Note**
+>
+> Модель `Ridge` имеет коэффициент регуляризации `alpha`, который помогает избавиться модели от переобучения, однако даже при стандартном его значении в единицу, модель показывает очень низкий коэффициент детерминации, поэтому варьирование его значения не принесёт никаких результатов.
+
+Исходя из полученных результатов можно сделать вывод, что модель гребневой регрессии неприменима к данному набору данных.

arutunyan_dmitry_lab_5/main.py

@@ -0,0 +1,65 @@
+import pandas as pd
+import numpy as np
+from matplotlib import pyplot as plt
+from sklearn import metrics
+from sklearn.linear_model import Ridge
+
+filein = "P:\\ULSTU\\ИИС\\Datasets\\heart_2020_norm.csv"
+
+
+# Метод решения задачи предсказания на всех признаках данных
+def ridge_all():
+    df = pd.read_csv(filein, sep=',')
+
+    x_train = df.drop("HeartDisease", axis=1).iloc[0:round(len(df) / 100 * 99)]
+    y_train = df["HeartDisease"].iloc[0:round(len(df) / 100 * 99)]
+    x_test = df.drop("HeartDisease", axis=1).iloc[round(len(df) / 100 * 99):len(df)]
+    y_test = df["HeartDisease"].iloc[round(len(df) / 100 * 99):len(df)]
+
+    rid = Ridge(alpha=1.0)
+    rid.fit(x_train.values, y_train.values)
+    y_predict = rid.predict(x_test.values)
+    err = pred_errors(y_predict, y_test.values)
+    make_plots(y_test.values, y_predict, err[0], err[1], "Гребневая регрессия (все признаки)")
+
+
+# Метод решения задачи предсказания на значимых признаках данных
+def ridge_valuable():
+    df = pd.read_csv(filein, sep=',')
+
+    x_train = df[["BMI", "PhysicalHealth", "MentalHealth", "AgeCategory", "Race",
+                  "PhysicalActivity", "GenHealth", "SleepTime", ]].iloc[0:round(len(df) / 100 * 99)]
+    y_train = df["HeartDisease"].iloc[0:round(len(df) / 100 * 99)]
+    x_test = df[["BMI", "PhysicalHealth", "MentalHealth", "AgeCategory", "Race",
+                 "PhysicalActivity", "GenHealth", "SleepTime", ]].iloc[round(len(df) / 100 * 99):len(df)]
+    y_test = df["HeartDisease"].iloc[round(len(df) / 100 * 99):len(df)]
+
+    rid = Ridge(alpha=1.0)
+    rid.fit(x_train.values, y_train.values)
+    y_predict = rid.predict(x_test.values)
+    err = pred_errors(y_predict, y_test.values)
+    make_plots(y_test.values, y_predict, err[0], err[1], "Гребневая регрессия (значимые признаки)")
+
+
+# Метод рассчёта ошибок
+def pred_errors(y_predict, y_test):
+    mid_square = np.round(np.sqrt(metrics.mean_squared_error(y_test, y_predict)),3)            # Рассчёт среднеквадратичной ошибки модели
+    det_kp = np.round(metrics.r2_score (y_test, y_predict), 2)                                 # Рассчёт коэфициента детерминации модели
+    return mid_square, det_kp
+
+
+# Метод отрисовки графиков
+def make_plots(y_test, y_predict, mid_sqrt, det_kp, title):
+        plt.plot(y_test, c="red", label="\"y\" исходная")                                # Создание графика исходной функции
+        plt.plot(y_predict, c="green", label="\"y\" предсказанная \n"
+                                                  "Ср^2 = " + str(mid_sqrt) + "\n"
+                                                  "Кд = " + str(det_kp))                       # Создание графика предсказанной функции
+        plt.legend(loc='lower left')
+        plt.title(title)
+        plt.savefig('static/' + title + '.png')
+        plt.close()
+
+
+if __name__ == '__main__':
+    ridge_all()
+    ridge_valuable()

arutunyan_dmitry_lab_6/README.md

@@ -0,0 +1,110 @@
+
+## Лабораторная работа 6. Вариант 4.
+### Задание 
+Использовать нейронную сеть `MLPRegressor` для данных из курсовой работы. Самостоятельно сформулировав задачу. Интерпретировать результаты и оценить, насколько хорошо он подходит для решения сформулированной задачи.
+
+### Как запустить
+Для запуска программы необходимо с помощью командной строки в корневой директории файлов прокета прописать:
+```
+python main.py
+```
+После этого в папке `static` сгенерируются график, по которому оценивается результат выполнения программы.
+
+### Используемые технологии
+- Библиотека `numpy`, используемая для обработки массивов данных и вычислений
+- Библиотека `pyplot`, используемая для построения графиков.
+- Библиотека `pandas`, используемая для работы с данными для анализа scv формата.
+- Библиотека `sklearn` - большой набор функционала для анализа данных. Из неё были использованы инструменты:
+    - `train_test_split` - разделитель данных на обучающиую и тестовую выборки
+    - `metrics` - набор инструменов для оценки моделей
+    - `MLPRegressor` - инструмент работы с моделью "Многослойный перцептрон для задачи регрессии"
+
+`MLPRegressor` - это тип искусственной нейронной сети, состоящей из нескольких слоев нейронов, включая входной слой, скрытые слои и выходной слой.
+Этот класс позволяет создавать и обучать MLP-модель для предсказания непрерывных числовых значений.
+
+### Описание работы
+#### Описание набора данных
+Набор данных - набор для определения возможности наличия ССЗ заболеваний у челоека
+
+Названия столбцов набора данных и их описание:
+
+ * HeartDisease - Имеет ли человек ССЗ (No / Yes),
+ * BMI - Индекс массы тела человека (float),
+ * Smoking - Выкурил ли человек хотя бы 5 пачек сигарет за всю жизнь (No / Yes),
+ * AlcoholDrinking - Сильно ли человек употребляет алкоголь (No / Yes),
+ * Stroke - Был ли у человека инсульт (No / Yes),
+ * PhysicalHealth - Сколько дней за последний месяц человек чувствовал себя плохо (0-30),
+ * MentalHealth - Сколько дней за последний месяц человек чувствовал себя удручённо (0-30),
+ * DiffWalking - Ииспытывает ли человек трудности при ходьбе (No / Yes),
+ * Sex - Пол (female, male),
+ * AgeCategory - Возрастная категория (18-24, 25-29, 30-34, 35-39, 40-44, 45-49, 50-54, 55-59, 60-64, 65-69, 70-74, 75-79, 80 or older),
+ * Race - Национальная принадлежность человека (White, Black, Hispanic, American Indian/Alaskan Native, Asian, Other),
+ * Diabetic - Был ли у человека диабет (No / Yes),
+ * PhysicalActivity - Занимался ли человек спротом за последний месяц (No / Yes),
+ * GenHealth - Общее самочувствие человека (Excellent, Very good, Good, Fair, Poor),
+ * SleepTime - Сколько человек в среднем спит за 24 часа (0-24),
+ * Asthma - Была ли у человека астма (No / Yes),
+ * KidneyDisease - Было ли у человека заболевание почек (No / Yes),
+ * SkinCancer - Был ли у человека рак кожи (No / Yes).
+
+Ссылка на страницу набора на kuggle: [Indicators of Heart Disease](https://www.kaggle.com/datasets/kamilpytlak/personal-key-indicators-of-heart-disease/data)
+
+#### Формулировка задачи
+Поскольку модель `MLPRegressor` используется для решения задачи регресси, то попробуем на ней предсказать поведение параметров при обучении на всех признаках, варьируя конфигурации модели. Сформулируем задачу:
+> "Решить задачу предсказания с помощью нейронной сети, обученной на всех признаках при различных конфигурациях. Сравнить результаты работы моделей"
+
+#### Решение задачи предсказания
+Из csv файла выргузим набор данных, выделим параметр для предсказания - (столбец `HeartDisease`), и его признаки - все остальные столбцы. Разделим данные на обучающую и тестовые выборки, при условии, что 99.9% данных - для обучения, а остальные для тестов:
+```python
+х, y = [df.drop("HeartDisease", axis=1).values, df["HeartDisease"].values]
+x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.001, random_state=42)
+```
+Создадим класс нейронной сети и определим варьируемые конфигурации. 
+
+`hidden_layer_sizes ` - параметр, принимающий на вход количество скрытых слоёв нейронной сети и количество нейронов в каждом слое. Для определения его наилучшего значения необходимо взять минимальное количество слоёв и нейронов в слое и постепенно увеличивать его, до тех пор, пока качество модели не перестанет улучшаться или не будет достаточным.
+> **Note**
+>
+> Экспериментально для нейронной сети `MLPRegressor` было выявленно наилучшее значение равное 100 слоям нейронной сети по 50 нейронов в каждой. Для прелоставления данных процесс оказался очень длительным, поэтому будет указан только наилучший результат.
+
+`activation` - функция активации. В классе представлена 4мя решениями:
+- `identity` - функция `f(x) = x`, абсолютно линейная идентичная функция для приведения работы нейронной сети ближе к модели линейной регрессии,
+- `logistic` - логистическая сигмовидная функция вида `f(x) = 1 / (1 + exp(-x))`,
+- `tanh` - гиперболическая функция тангенса `f(x) = tanh(x)`,
+- `relu` - функция выпрямленной линейной единицы измерения `f(x) = max(0, x)`, проверяет больше ли х нуля (используется чаще всего).
+
+`solver` - метод оптимизации весов. Существует в 3х вариациях:
+- `Bfgs` - оптимизатор из семейства квазиньютоновских методов, 
+> **Warning**
+>
+> Оптимизатор из семейства квазиньютоновских методов показал себя как очень жадный по времени выполнения алгоритм при этом использующий большие коэфициенты весов, что приводило к едиичным, но слишком большим погрешностям на данных. Поэтому в эксперименте варьирования он не принимал участия.
+
+- `sgd` - метод стозастического градиентного спуска (классика),
+- `adam` - оптимизированный метод стозастического градиентного спуска Кингмы, Дидерика и Джимми Барнсома.
+
+```python
+mlp = MLPRegressor(hidden_layer_sizes=(100, 50), activation='relu', solver='adam', random_state=42)
+mlp.fit(x_train, y_train)
+y_predict = mlp.predict(x_test)
+err = pred_errors(y_predict, y_test)
+```
+Проведём эксперимент варьирования конфигураций, посчитаем ошибки предсказания и выберем наилучшую нейронную сеть.
+
+#### Эксперимент варьирования
+Рассмотрим различные функции активации.
+
+Графики решения задачи предсказания на разных функциях активации:
+
+![](1.png "")
+
+Теперь для выбранной функции подберём лучший метод оптимизации весов.
+
+Грфики решения задачи предсказания на разных методах оптимизации весов:
+
+![](2.png "")
+
+### Вывод
+Согласно графиком, наилучшие результаты показала нейронаая сеть с функцией активации гиперболического тангенса `tanh` и методом оптимизации весов путём оптимизированного стозастического градиентного спуска Кингмы, Дидерика и Джимми Барнсома `adam`.
+
+В целом нейронная сеть справилась неудовлетворительно с задачей предсказания, показав хоть и небольшую среднеквадратическую ошибку в 0.25, но очень низкий коэфициент детерминации в 0.23 максимально. 
+
+Это значит, что теоретически модель может предсказать результат по признакам, однако понимания зависимостей результата от последних у неё мало. 

arutunyan_dmitry_lab_6/main.py

@@ -0,0 +1,46 @@
+import pandas as pd
+import numpy as np
+from matplotlib import pyplot as plt
+from sklearn import metrics
+from sklearn.model_selection import train_test_split
+from sklearn.neural_network import MLPRegressor
+
+filein = "P:\\ULSTU\\ИИС\\Datasets\\heart_2020_norm.csv"
+
+
+# Метод обучения нейронной сети
+def reg_neural_net():
+    df = pd.read_csv(filein, sep=',')
+    x, y = [df.drop("HeartDisease", axis=1).values,
+            df["HeartDisease"].values]
+
+    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.001, random_state=42)
+
+    mlp = MLPRegressor(hidden_layer_sizes=(100, 50), activation='tanh', solver='adam', random_state=15000)
+    mlp.fit(x_train, y_train)
+    y_predict = mlp.predict(x_test)
+    err = pred_errors(y_predict, y_test)
+    make_plots(y_test, y_predict, err[0], err[1], "Нейронная сеть")
+
+
+# Метод рассчёта ошибок
+def pred_errors(y_predict, y_test):
+    mid_square = np.round(np.sqrt(metrics.mean_squared_error(y_test, y_predict)),3)            # Рассчёт среднеквадратичной ошибки модели
+    det_kp = np.round(metrics.r2_score(y_test, y_predict), 2)                                  # Рассчёт коэфициента детерминации модели
+    return mid_square, det_kp
+
+
+# Метод отрисовки графиков
+def make_plots(y_test, y_predict, mid_sqrt, det_kp, title):
+        plt.plot(y_test, c="red", label="\"y\" исходная")                                # Создание графика исходной функции
+        plt.plot(y_predict, c="green", label="\"y\" предсказанная \n"
+                                                  "Ср^2 = " + str(mid_sqrt) + "\n"
+                                                  "Кд = " + str(det_kp))                       # Создание графика предсказанной функции
+        plt.legend(loc='lower left')
+        plt.title(title)
+        plt.savefig('static/' + title + '.png')
+        plt.close()
+
+
+if __name__ == '__main__':
+    reg_neural_net()

gordeeva_anna_lab_2/lab2.py

@@ -0,0 +1,97 @@
+import streamlit as st
+import numpy as np
+from sklearn.linear_model import Lasso
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.linear_model import LassoCV
+from sklearn.feature_selection import SelectFromModel
+from sklearn.feature_selection import RFE
+
+st.header("Лабораторная работа 2. Вариант 7. Лассо, случайное лассо, рекурсивное сокращение признаков")
+
+# генерируем исходные данные: 750 строк-наблюдений и 14 столбцов-признаков
+np.random.seed(0) #делаем случайные числа предсказуемыми, чтобы при каждом сбросе, рандомные числа были одинаковы
+size = 750
+X = np.random.uniform(0, 1, (size, 14))
+# Задаем функцию-выход: регрессионную проблему Фридмана
+Y = (10 * np.sin(np.pi * X[:, 0] * X[:, 1]) + 20 * (X[:, 2] - .5) ** 2 +
+     10 * X[:, 3] + 5 * X[:, 4] ** 5 + np.random.normal(0, 1))
+# Добавляем зависимость признаков
+X[:, 10:] = X[:, :4] + np.random.normal(0, .025, (size, 4))
+
+
+# Создание списка пар в формате: номер признака - средняя оценка
+names = ["x%s" % i for i in range(1, 15)]  # Список имен признаков
+
+def random_lasso(X, Y, n_subsets=100):
+    n_samples, n_features = X.shape
+    selected_features = np.zeros(n_features)
+
+    for _ in range(n_subsets):
+        # Создаем случайное подмножество признаков
+        subset_indices = np.random.choice(n_features, int(n_features * 0.7), replace=False)
+        X_subset = X[:, subset_indices]
+
+        # Создаем LassoCV модель
+        lasso_cv = LassoCV(alphas=[0.05])
+
+        # Обучаем модель на подмножестве признаков
+        lasso_cv.fit(X_subset, Y)
+
+        # Определяем, какие признаки были выбраны
+        selected_features[subset_indices] += (lasso_cv.coef_ != 0)
+
+    # Вычисляем, какие признаки были выбраны чаще всего
+    most_selected_features = np.where(selected_features > n_subsets / 2)[0]
+
+    return most_selected_features
+
+def rank_to_dict(ranks, name):
+    ranks = np.abs(ranks)
+    minmax = MinMaxScaler()
+    ranks = minmax.fit_transform(np.array(ranks).reshape(-1, 1)).ravel()
+    ranks = list(map(lambda x: round(x, 2), ranks))
+    ranked_features = list(zip(name, ranks))
+    return ranked_features
+
+def mean_rank(ranks):
+    total = sum(rank for _, rank in ranks)
+    return total / len(ranks)
+
+# Переключатели
+lasso_check = st.checkbox("Лассо")
+random_lasso_check = st.checkbox("Случайное лассо")
+RFE_check = st.checkbox("Рекурсивное сокращение признаков")
+
+# Результаты
+if lasso_check:
+    model_lasso = Lasso(alpha=.05)
+    model_lasso.fit(X, Y)
+    rank = rank_to_dict(model_lasso.coef_, names)
+    mean = mean_rank(rank)
+    st.write("Получившиеся оценки для каждого признака")
+    st.table(rank)
+    st.write("Средняя оценка: ", mean)
+
+if random_lasso_check:
+    selected_features = random_lasso(X, Y)
+    X_subset = X[:, selected_features]
+    lasso_cv = LassoCV(alphas=[0.05])
+    lasso_cv.fit(X_subset, Y)
+    rank = rank_to_dict(lasso_cv.coef_, [names[i] for i in selected_features])
+    mean = mean_rank(rank)
+    st.write("Получившиеся оценки")
+    st.table(rank)
+    st.write("Средняя оценка: ", mean)
+
+if RFE_check:
+    model_lasso = Lasso(alpha=0.05)
+    rfe = RFE(model_lasso, n_features_to_select=4)
+    rfe.fit(X, Y)
+    selected_feature_indices = rfe.support_
+    selected_feature_names = [name for i, name in enumerate(names) if selected_feature_indices[i]]
+    rank = rank_to_dict(rfe.ranking_, selected_feature_names)
+    mean = mean_rank(rank)
+    st.write("Получившиеся оценки")
+    st.table(rank)
+    st.write("Средняя оценка: ", mean)
+

gordeeva_anna_lab_2/readme.md

@@ -0,0 +1,56 @@
+## Задание
+Модели:
+* Лассо (Lasso)
+* Случайное лассо (RandomizedLasso)
+* Рекурсивное сокращение признаков (Recursive Feature Elimination – RFE)
+
+## В чем различие каждой модели
+
+Лассо (Lasso) автоматически отбирает наиболее важные признаки и уменьшает влияние менее важных.
+
+Случайное лассо (RandomizedLasso) случайным образом выбирает подмножества признаков из исходных данных и применяет Лассо к каждому из них. Затем он объединяет результаты и определяет, какие признаки были выбраны чаще всего.
+
+Рекурсивное сокращение признаков (Recursive Feature Elimination – RFE) оценивает важность каждого признака. Затем он удаляет наименее важный признак и повторяет процесс, пока не останется желаемое количество признаков.
+
+
+## Библиотеки
+Streamlit. Предоставляет простой способ создания веб-приложений для визуализации данных.
+
+Numpy. Предоставляет возможность работать с массивами и матрицами.
+
+Sklearn. Предоставляет инструменты и алгоритмы, которые упрощают задачи, связанные с машинным обучением.
+
+## Функционал
+* Генерация исходных данных из 750 строк-наблюдений и 14 столбцов-признаков
+* Создание и обучение таких моделей, как лассо, случайное лассо и рекурсивное сокращение признаков.
+* Вывод получившихся оценок для признаков и средней оценки.
+
+## Запуск
+Перед запуском необходимо запустить виртуальную среду venv. Так как я использую streamlit, то для запуска необходимо в терминал прописать следующую строку:
+```
+streamlit run lab1.py
+```
+Приложение развернется на локальном сервере и автоматически откроется в браузере.
+
+## Скриншоты работы программы
+Лассо (Lasso)
+
+![Alt text](Lasso_screen.png "Optional Title")
+
+Случайное лассо (RandomizedLasso)
+
+![Alt text](RandLasso_screen.png "Optional Title")
+
+Рекурсивное сокращение признаков (Recursive Feature Elimination – RFE)
+
+![Alt text](RFE_screen.png "Optional Title")
+
+## Вывод
+Модель лассо выводит все 14 признаков, наиболее важными признаками оказались под индексом
+1, 2, 4 и 5. Самый важный признак под номером 4. Средняя оценка по всем признакам 0.19.
+
+Модель случайное лассо выводит наиболее важные признаки, такими признаками являются 1, 2, 4 и 5. Средняя оценка же по этим признакам равна 0.53. Она выше, так как мы исключаем маловажные признаки.
+
+Модель рекурсивного сокращения признаков выводит 4 признака, так как я указала именно вывод 4 признаков в коде программы. Таким образом, модель отсекает маловажные признаки. Самым важным признаком оказался под номером 4. Средняя оценка: 0.25.
+
+Как итог, можно сказать, что наиболее важными признаками являются 1, 2, 4 и 5. А самым важным из них является признак под номером 4.

gusev_vladislav_lab_3/README.md

@@ -0,0 +1,27 @@
+### Вариант 9
+### Задание на лабораторную работу:
+Решите с помощью библиотечной реализации дерева решений задачу: Запрограммировать дерево решений как минимум на 99% ваших данных для задачи: Зависимость глубины алмаза (depth) от длины (x), ширины (y) и высоты алмаза (z) . Проверить работу модели на оставшемся проценте, сделать вывод.
+
+### Как запустить лабораторную работу:
+Выполняем файл gusev_vladislav_lab_3.py, решение будет в консоли.
+
+### Технологии
+Sklearn - библиотека с большим количеством алгоритмов машинного обучения. Нам понадобится библиотека для дерева решения регрессии sklearn.tree.DecisionTreeRegressor.
+
+### По коду
+1) Для начала загружаем данные из csv файла
+2) Разделеям данные на признаки (X) и целевую переменную (y)
+3) Разделяем данные на обучающее и тестовые
+4) Обучаем дерево регрессией (model)
+5) Выводим важность признаков, предсказание значений на тестовой выборке и оценку производительности модели
+
+Пример:
+
+![img.png](img.png)
+
+### Вывод
+- score: ~0.88. Это мера того, насколько хорошо модель соответствует данным. По значению 88% можно сказать, что модель хорошо соответствует данным.
+- feature_importances: ~0.26, ~0.34, ~0,39. Это говорит о важности признаков для нашей модели. Можно сказать, что высота (z) имеет наибольшую важность.
+- Mean Squared Error: 0.22. Это ошибка модели. Это говорит о том, что модель в среднем ошибается в 22% случаев.
+
+По итогу можно сказать, что модель отработала хорошо, из-за score ~0.88.

gusev_vladislav_lab_3/gusev_vladislav_lab_3.py

@@ -0,0 +1,31 @@
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeRegressor
+from sklearn.metrics import mean_squared_error
+
+# Загрузка данных из csv-файла
+data = pd.read_csv('diamonds_prices.csv', index_col='diamond_id')
+
+# Разделение данных на признаки (X) и целевую переменную (y)
+X = data[['x', 'y', 'z']]
+
+print (X.head())
+y = data['depth']
+
+# Разделение данных на обучающую и тестовую выборки
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.01, random_state=42)
+
+#Решение с помощью дерева регрессии
+model = DecisionTreeRegressor()
+model.fit(X_train, y_train)
+test_score = model.score(X_test, y_test)
+# Получение важности признаков
+feature_importances = model.feature_importances_
+# Предсказание значений на тестовой выборке
+y_pred = model.predict(X_test)
+# Оценка производительности модели
+mse = mean_squared_error(y_test, y_pred)
+
+print("score", test_score)
+print("feature_importances", feature_importances)
+print("Mean Squared Error: {:.2f}".format(mse))

ilbekov_dmitriy_lab_1/README.md

@@ -0,0 +1,35 @@
+# Лабораторная работа 1
+### Вариант 10
+
+### Данные: 
+- make_moons (noise=0.3, random_state=rs)
+### Модели:
+- Линейную регрессию
+- Многослойный персептрон с 10-ю нейронами в скрытом слое (alpha = 0.01)
+- Многослойный персептрон со 100-а нейронами в скрытом слое (alpha = 0.01)
+### Запуск
+- Запустить файл lab1.py
+
+### Технологии
+- Язык - 'Python'
+- Библиотеки sklearn, matplotlib, numpy
+
+### Что делает
+Программа генерирует набор данных с помощью make_moons(), после чего строит графики для моделей, указанных в задании варианта и выводит в консоль качество данных моделей
+
+### Пример работы
+Вывод в консоль:
+
+Точность: 
+
+LinearRegression: 0.1997177824893414
+
+Multi Layer Perceptron 10 нейронов: 0.45
+
+Multi Layer Perceptron 100 нейронов: 0.8
+
+Лучший результат показала модель Multi Layer Perceptron на 100 нейронах
+
+Ниже представлены графики, выводимые программой
+
+![Graphics](graphics.png)

ilbekov_dmitriy_lab_1/lab1.py

@@ -0,0 +1,103 @@
+import numpy as np
+from sklearn import metrics
+from sklearn.datasets import make_moons
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression
+from sklearn.neural_network import MLPClassifier
+from sklearn.metrics import accuracy_score
+from matplotlib import pyplot as plt
+
+#Задание случайного состояния
+rs = 35
+# Генерации синтетического набора данных в форме двух полумесяцев
+# noise - уровень шума данных
+# random_state устанавливается в rs для воспроизводимости данных
+X, y = make_moons(noise=0.3, random_state=rs)
+
+# test_size какой процент данных пойдет в тестирование
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=rs)
+
+# Подготовка для визуализации
+x_minimal, x_maximum = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
+y_minimal, y_maximum = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
+xx, yy = np.meshgrid(np.arange(x_minimal, x_maximum, 0.02), np.arange(y_minimal, y_maximum, 0.02))
+
+
+# ЛИНЕЙНАЯ РЕГРЕССИЯ
+
+# Инициализация модели
+linear_regression = LinearRegression()
+# Обучение
+linear_regression.fit(X_train, y_train)
+# Предсказание
+y_pred_linear_regression = linear_regression.predict(X_test)
+# Оценка точности (MSE)
+accuracy_linear_regression = metrics.mean_squared_error(y_test, y_pred_linear_regression)
+# Предсказание класса для каждой точки в сетке графика и изменение формы результата
+Z_linear_regression = linear_regression.predict(np.c_[xx.ravel(), yy.ravel()])
+Z_linear_regression = Z_linear_regression.reshape(xx.shape)
+
+
+# МНОГОСЛОЙНЫЙ ПЕРСЕПТРОН (10)
+
+# Инициализация модели
+multi_layer_perceptron_10 = MLPClassifier(hidden_layer_sizes=(10,), alpha=0.01, random_state=rs)
+# Обучение
+multi_layer_perceptron_10.fit(X_train, y_train)
+# Предсказание
+y_pred_multi_layer_perceptron_10 = multi_layer_perceptron_10.predict(X_test)
+# Оценка точности каждой модели сравнивается с истинными метками классов на тестовой выборке
+accuracy_mlp_10 = accuracy_score(y_test, y_pred_multi_layer_perceptron_10)
+# Предсказание класса для каждой точки в сетке графика и изменение формы результата
+Z_mlp_10 = multi_layer_perceptron_10.predict(np.c_[xx.ravel(), yy.ravel()])
+Z_mlp_10 = Z_mlp_10.reshape(xx.shape)
+
+
+# МНОГОСЛОЙНЫЙ ПЕРСЕПТРОН (100)
+
+# Инициализация модели
+multi_layer_perceptron_100 = MLPClassifier(hidden_layer_sizes=(100,), alpha=0.01, random_state=rs)
+# Обучение
+multi_layer_perceptron_100.fit(X_train, y_train)
+# Предсказание
+y_pred_multi_layer_perceptron_100 = multi_layer_perceptron_100.predict(X_test)
+# Оценка точности (MSE)
+accuracy_mlp_100 = accuracy_score(y_test, y_pred_multi_layer_perceptron_100)
+# Предсказание класса для каждой точки в сетке графика и изменение формы результата
+Z_mlp_100 = multi_layer_perceptron_100.predict(np.c_[xx.ravel(), yy.ravel()])
+Z_mlp_100 = Z_mlp_100.reshape(xx.shape)
+
+
+# ВЫВОД: результаты оценки точности (в консоли) и график
+print("Точность: ")
+print("LinearRegression:", accuracy_linear_regression)
+print("Multi Layer Perceptron 10 нейронов:", accuracy_mlp_10)
+print("Multi Layer Perceptron 100 нейронов:", accuracy_mlp_100)
+
+plt.figure(figsize=(12, 9))
+plt.subplot(221)
+plt.contourf(xx, yy, Z_linear_regression, alpha=0.8)
+plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, edgecolors='k', alpha=0.6)
+plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, edgecolors='k')
+plt.title('Линейная регрессия')
+plt.xlabel('Признак 1')
+plt.ylabel('Признак 2')
+
+plt.subplot(222)
+plt.contourf(xx, yy, Z_mlp_10, alpha=0.8)
+plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, edgecolors='k', alpha=0.6)
+plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, edgecolors='k')
+plt.title('MLP 10 нейронов')
+plt.xlabel('Признак 1')
+plt.ylabel('Признак 2')
+
+plt.subplot(223)
+plt.contourf(xx, yy, Z_mlp_100, alpha=0.8)
+plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, edgecolors='k', alpha=0.6)
+plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, edgecolors='k')
+plt.title('MLP 100 нейронов')
+plt.xlabel('Признак 1')
+plt.ylabel('Признак 2')
+
+plt.tight_layout()
+plt.show()

ilbekov_dmitriy_lab_2/README.md

@@ -0,0 +1,23 @@
+# Лабораторная работа 2
+### Вариант 10
+
+### Задание: 
+- Выполнить ранжирование  признаков  с  помощью  указанных  по варианту моделей
+### Модели:
+- Линейная регрессия (LinearRegression)
+- Лассо (Lasso)
+- Рекурсивное сокращение признаков (Recursive Feature Elimination –RFE)
+### Запуск
+- Запустить файл lab2.py
+
+### Технологии
+- Язык - 'Python'
+- Библиотеки sklearn, numpy
+
+### Что делает
+Программа выполняет ранжирование признаков набора данных с помощью моделей, указанных в задании варианта и выводит в консоль результаты ранжирования и топ 4 самых выжных признака
+
+### Пример работы
+Пример работы представлен в виде скриншота:
+
+![Graphics](console.jpg)

ilbekov_dmitriy_lab_2/lab2.py

@@ -0,0 +1,80 @@
+from sklearn.linear_model import LinearRegression, Lasso
+from sklearn.feature_selection import RFE
+from sklearn.preprocessing import MinMaxScaler
+import numpy as np
+
+
+# Генерация синтетических данных
+def create_data():
+    np.random.seed(0)
+    size = 750
+    X = np.random.uniform(0, 1, (size, 14))
+    Y = (10 * np.sin(np.pi * X[:, 0] * X[:, 1]) + 20 * (X[:, 2] - .5) ** 2 +
+         10 * X[:, 3] + 5 * X[:, 4] ** 5 + np.random.normal(0, 1))
+    X[:, 10:] = X[:, :4] + np.random.normal(0, .025, (size, 4))
+    return X, Y
+
+
+# Нормализация значений рангов
+def rank_to_dict(ranks):
+    ranks = np.abs(ranks)
+    names = ["x%s" % i for i in range(1, 15)]
+    minmax = MinMaxScaler()
+    ranks = minmax.fit_transform(np.array(ranks).reshape(14, 1)).ravel()
+    ranks = map(lambda x: round(x, 2), ranks)
+    return dict(zip(names, ranks))
+
+
+# Вывод отсортированных признаков по важности в табличном виде
+def print_sorted_features_by_models(ranks_by_model: {}):
+    sorted_ranks = sorted(ranks_by_model.items(), key=lambda item: sum(item[1].values()), reverse=True)
+
+    print("{:<40}".format(""), end="")
+    for i in range(1, 15):
+        print("{:<10}".format(i), end="")
+    print()
+
+    for model, rank_dict in sorted_ranks:
+        sorted_features = sorted(rank_dict.items(), key=lambda item: item[1], reverse=True)
+        print("{:<40}".format(model), end="")
+        for feature, rank in sorted_features:
+            print("{:<10}".format(f"{feature}: {rank}"), end="")
+        print()
+    print()
+
+
+# Получение средних значений моделей и ТОП 4 самых важных признака
+def average_values(ranks_by_model: {}):
+    mean = {}
+    for model, rank_dict in ranks_by_model.items():
+        for feature, rank in rank_dict.items():
+            if feature not in mean:
+                mean[feature] = 0
+            mean[feature] += rank
+    mean = {feature: round(rank / len(ranks_by_model), 2) for feature, rank in mean.items()}
+    mean_sorted = sorted(mean.items(), key=lambda item: item[1], reverse=True)
+    print("Средние значения")
+    print(mean_sorted)
+    print("\nТОП 4 самых важных признака по среднему значению: ")
+    for feature, rank in mean_sorted[:4]:
+        print('Признак - {0}, значение важности - {1}'.format(feature, rank))
+
+
+X, Y = create_data()
+# ЛИНЕЙНАЯ РЕГРЕССИЯ
+linear_regression = LinearRegression()
+linear_regression.fit(X, Y)
+# ЛАССО
+lasso = Lasso(alpha=.01)
+lasso.fit(X, Y)
+# РЕКУРСИВНОЕ СОКРАЩЕНИЕ ПРИЗНАКОВ
+rfe = RFE(linear_regression)
+rfe.fit(X, Y)
+
+ranks_by_model = {
+    "Линейная регрессия": rank_to_dict(linear_regression.coef_),
+    "Лассо": rank_to_dict(lasso.coef_),
+    "РЕКУРСИВНОЕ СОКРАЩЕНИЕ ПРИЗНАКОВ (RFE)": rank_to_dict(rfe.ranking_),
+}
+print_sorted_features_by_models(ranks_by_model)
+average_values(ranks_by_model)

lipatov_ilya_lab_2/README.md

@@ -0,0 +1,38 @@
+## Лабораторная работа №2
+
+### Ранжирование признаков
+
+## Выполнил студент группы ПИбд-41 Липатов Илья
+
+### Как запустить лабораторную работу:
+
+* установить python, numpy, matplotlib, sklearn
+* запустить проект (стартовая точка класс lab2)
+
+### Какие технологии использовались:
+
+* Язык программирования `Python`, библиотеки numpy, matplotlib, sklearn
+* Среда разработки `PyCharm`
+
+### Что делает лабораторная работа:
+
+* генерирует данные и обучает модели модели RandomizedLasso, Ridge,Random Forest Regressor.
+* ранжирует признаки с помощью моделей RandomizedLasso, Ridge,Random Forest Regressor.
+* отображает получившиеся значения\оценки каждого признака каждым методом\моделью и среднюю оценку.
+
+### Примеры работы:
+
+#### Результаты:
+* RandomizedLasso: 1, 2, 4, 5
+* Ridge: 4, 11, 12 и 1 или 2 (одинаковый результат)
+* Random Forest Regressor: 4, 1 11, 12
+
+#### Среднее: 4, 1, 2 и 5 признаки
+
+#### Графики результатов ранжирования признаков по каждой модели и средняя оценка:
+
+![Result](result.png)
+
+#### Средние оценки для признаков у каждой модели и средние оценки моделей:
+
+![Means](means.png)

lipatov_ilya_lab_2/RandomizedLasso.py

@@ -0,0 +1,44 @@
+from sklearn.utils import check_X_y, check_random_state
+from sklearn.linear_model import Lasso
+from scipy.sparse import issparse
+from pandas._libs import sparse
+
+
+def _rescale_data(x, weights):
+    if issparse(x):
+        size = weights.shape[0]
+        weight_dia = sparse.dia_matrix((1 - weights, 0), (size, size))
+        x_rescaled = x * weight_dia
+    else:
+        x_rescaled = x * (1 - weights)
+
+    return x_rescaled
+
+
+class RandomizedLasso(Lasso):
+    def __init__(self, weakness=0.5, alpha=1.0, fit_intercept=True, normalize=False,
+                 precompute=False, copy_x=True, max_iter=1000,
+                 tol=1e-4, warm_start=False, positive=False,
+                 random_state=None, selection='cyclic'):
+        self.weakness = weakness
+        super(RandomizedLasso, self).__init__(
+            alpha=alpha, fit_intercept=fit_intercept,
+            normalize=normalize, precompute=precompute, copy_X=copy_x,
+            max_iter=max_iter, tol=tol, warm_start=warm_start,
+            positive=positive, random_state=random_state,
+            selection=selection)
+
+    def fit(self, x, y):
+        if not isinstance(self.weakness, float) or not (0.0 < self.weakness <= 1.0):
+            raise ValueError('weakness should be a float in (0, 1], got %s' % self.weakness)
+
+        x, y = check_X_y(x, y, accept_sparse=True)
+
+        n_features = x.shape[1]
+        weakness = 1. - self.weakness
+        random_state = check_random_state(self.random_state)
+
+        weights = weakness * random_state.randint(0, 1 + 1, size=(n_features,))
+
+        x_rescaled = _rescale_data(x, weights)
+        return super(RandomizedLasso, self).fit(x_rescaled, y)

lipatov_ilya_lab_2/lab2.py

@@ -0,0 +1,67 @@
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.preprocessing import MinMaxScaler
+from RandomizedLasso import RandomizedLasso
+from sklearn.linear_model import Ridge
+from matplotlib import pyplot as plt
+import numpy as np
+
+np.random.seed(0)
+size = 1000
+X = np.random.uniform(0, 1, (size, 14))
+Y = (10 * np.sin(np.pi * X[:, 0] * X[:, 1]) + 20 * (X[:, 2] - .5) ** 2 + 10 * X[:, 3] + 5 * X[:, 4] ** 5 + np.random.normal(0, 1))
+X[:, 10:] = X[:, :4] + np.random.normal(0, .025, (size, 4))
+
+ridge = Ridge(alpha=1.0)
+ridge.fit(X, Y)
+
+lasso = RandomizedLasso(alpha=0.007)
+lasso.fit(X, Y)
+
+randForestRegression = RandomForestRegressor(max_depth=4, min_samples_leaf=1, min_impurity_decrease=0, ccp_alpha=0)
+randForestRegression.fit(X, Y)
+
+
+def rank_to_dict(ranks, names):
+    ranks = np.abs(ranks)
+    minmax = MinMaxScaler()
+    ranks = minmax.fit_transform(np.array(ranks).reshape(14, 1)).ravel()
+    ranks = map(lambda x: round(x, 2), ranks)
+    return dict(zip(names, ranks))
+
+
+ranks = {'Ridge': {}, 'RandomizedLasso': {}, 'RandomForestRegressor': {}}
+names = ["x%s" % i for i in range(1, 15)]
+
+ranks["Ridge"] = rank_to_dict(ridge.coef_, names)
+ranks["RandomizedLasso"] = rank_to_dict(lasso.coef_, names)
+ranks["RandomForestRegressor"] = rank_to_dict(randForestRegression.feature_importances_, names)
+
+mean = {}
+
+for key, value in ranks.items():
+    for item in value.items():
+        if item[0] not in mean:
+            mean[item[0]] = 0
+        mean[item[0]] += item[1]
+
+for key, value in mean.items():
+    res = value / len(ranks)
+    mean[key] = round(res, 2)
+
+print('VALUES')
+
+for r in ranks.items():
+    print(r)
+    print('MEAN')
+    print(mean)
+
+for i, (model_name, features) in enumerate(ranks.items()):
+    subplot = plt.subplot(2, 2, i + 1)
+    subplot.set_title(model_name)
+    subplot.bar(list(features.keys()), list(features.values()))
+
+subplot = plt.subplot(2, 2, 4)
+subplot.set_title('Mean')
+subplot.bar(list(mean.keys()), list(mean.values()))
+
+plt.show()

madyshev_egor_lab_3/main.py

@@ -0,0 +1,46 @@
+import numpy as np
+import pandas as pb
+import matplotlib.pyplot as plt
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression, Perceptron
+from sklearn.neural_network import MLPClassifier, MLPRegressor
+from sklearn.preprocessing import LabelEncoder, OneHotEncoder, MinMaxScaler
+from sklearn.tree import DecisionTreeRegressor, DecisionTreeClassifier
+
+df = pb.read_csv("StudentsPerformance.csv", sep=",", encoding="windows-1251")
+df1 = df
+print("Данные без подготовки:")
+with pb.option_context('display.max_rows', None, 'display.max_columns', None, 'display.width', 1000):
+    print(df[:5])
+
+def prepareStringData(columnName):
+    uniq = df[columnName].unique()
+    mp = {}
+    for i in uniq:
+        mp[i] = len(mp)
+    df[columnName] = df[columnName].map(mp)
+
+
+print()
+print("Данные после подготовки:")
+prepareStringData("gender")
+prepareStringData("race/ethnicity")
+prepareStringData("parental level of education")
+prepareStringData("lunch")
+prepareStringData("test preparation course")
+with pb.option_context('display.max_rows', None, 'display.max_columns', None, 'display.width', 1000):
+    print(df[:5])
+
+X = df[["gender", "race/ethnicity", "lunch", "test preparation course", "math score", "reading score", "writing score"]]
+y = df["parental level of education"]
+X_train, X_Test, y_train, y_test = train_test_split(X, y, test_size=0.01, random_state=42)
+dtc = DecisionTreeClassifier()
+dtc = dtc.fit(X_train, y_train)
+dtr = DecisionTreeRegressor()
+dtr = dtr.fit(X_train, y_train)
+print()
+print("Результат дерева класификации на учебных данных: ", dtc.score(X_train, y_train))
+print("Результат дерева класификации на тестовых данных: ", dtc.score(X_Test, y_test))
+print()
+print("Результат дерева регрессии на учебных данных: ", dtr.score(X_train, y_train))
+print("Результат дерева регрессии на тестовых данных: ", dtr.score(X_Test, y_test))

madyshev_egor_lab_3/readme.md

@@ -0,0 +1,41 @@
+# Задание
+Решите с помощью библиотечной реализации дерева решений задачу из лабораторной работы «Веб-сервис «Дерево решений» по предмету «Методы искусственного интеллекта» на 99% ваших данных. Проверьте работу модели на оставшемся проценте, сделайте вывод  
+## Задание по варианту
+Задача для дерева решений. Предсказание уровня образования родителей по всем остальных данным.  
+## Решение
+### Запуск программы
+Для запуска программы необходимо запустить файл main.py, содержащий код программы  
+### Используемые технологии
+Программа использует следующие библиотеки:  
+- numpy - библиотека для работы с массивами и матрицами.
+- matplotlib - библиотека для создания графиков и визуализации данных.
+- sklearn - библиотека для машинного обучения и анализа данных.
+### Что делает программа
+Программа читает данные из csv файла. Подготавливает их для работы модели, приводя текстовые параметры к числам.  И пытается научиться предсказывать уровень образования родителей по данным об их детях.
+### Тесты
+Данные без подготовки:  
+   gender race/ethnicity parental level of education         lunch test preparation course  math score  reading score  writing score  
+0  female        group B           bachelor's degree      standard                    none          72             72             74  
+1  female        group C                some college      standard               completed          69             90             88  
+2  female        group B             master's degree      standard                    none          90             95             93  
+3    male        group A          associate's degree  free/reduced                    none          47             57             44  
+4    male        group C                some college      standard                    none          76             78             75  
+  
+Данные после подготовки:  
+   gender  race/ethnicity  parental level of education  lunch  test preparation course  math score  reading score  writing score  
+0       0               0                            0      0                        0          72             72             74  
+1       0               1                            1      0                        1          69             90             88  
+2       0               0                            2      0                        0          90             95             93  
+3       1               2                            3      1                        0          47             57             44  
+4       1               1                            1      0                        0          76             78             75  
+  
+Результат дерева классификации на учебных данных:  0.998989898989899  
+Результат дерева классификации на тестовых данных:  0.2  
+  
+Результат дерева регрессии на учебных данных:  0.9984005221729634  
+Результат дерева регрессии на тестовых данных:  -1.2264150943396226  
+
+По результатам двух типов моделей деревьев видно, что модель дерева решений не подходит для предсказания уровня образования родителей по этим данным. Или на практике не существует такой зависимости.  
+С целью проверки не переобучилась ли модель были проведены тесты с изменением параметров программы.  
+Изменение объема обучающей выборки и регулирование параметров моделей деревьев результат не поменяло.  
+Это значит, что модель не была переобучена.  

madyshev_egor_lab_4/main.py

@@ -0,0 +1,54 @@
+import numpy as np
+import pandas as pb
+import matplotlib.pyplot as plt
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression, Perceptron
+from sklearn.neural_network import MLPClassifier, MLPRegressor
+from sklearn.preprocessing import LabelEncoder, OneHotEncoder, MinMaxScaler
+from sklearn.tree import DecisionTreeRegressor, DecisionTreeClassifier
+from scipy.cluster.hierarchy import dendrogram, linkage
+
+df = pb.read_csv("StudentsPerformance.csv", sep=",", encoding="windows-1251")
+df1 = df
+print("Данные без подготовки:")
+with pb.option_context('display.max_rows', None, 'display.max_columns', None, 'display.width', 1000):
+    print(df[:5])
+
+def prepareStringData(columnName):
+    uniq = df[columnName].unique()
+    mp = {}
+    for i in uniq:
+        mp[i] = len(mp)
+    df[columnName] = df[columnName].map(mp)
+
+
+print()
+print("Данные после подготовки:")
+prepareStringData("gender")
+prepareStringData("race/ethnicity")
+prepareStringData("parental level of education")
+prepareStringData("lunch")
+prepareStringData("test preparation course")
+with pb.option_context('display.max_rows', None, 'display.max_columns', None, 'display.width', 1000):
+    print(df[:5])
+
+
+X = df[:15]
+X = X[["math score", "reading score", "writing score"]].values
+labelList = []
+for i in X:
+    st = ""
+    for j in i:
+        st += str(j)
+        st += ","
+    st = "(" + st[:len(st) - 1] + ")"
+    labelList.append(st)
+linked = linkage(X, 'single')
+
+plt.figure(figsize=(10, 7))
+dendrogram(linked,
+            orientation='top',
+            labels=labelList,
+            distance_sort='descending',
+            show_leaf_counts=True)
+plt.show()

madyshev_egor_lab_4/readme.md

@@ -0,0 +1,24 @@
+# Задание
+Использовать метод кластеризации по варианту для данных из таблицы 1 по варианту (таблица 9), самостоятельно сформулировав задачу. Интерпретировать результаты и оценить, насколько хорошо он подходит для решения сформулированной вами задачи.    
+## Задание по варианту
+Задача для дерева решений. Предсказание уровня образования родителей по всем остальных данным.  
+## Решение
+### Запуск программы
+Алгоритм кластеризации: dendrogram
+### Используемые технологии
+Программа использует следующие библиотеки:  
+- numpy - библиотека для работы с массивами и матрицами.
+- matplotlib - библиотека для создания графиков и визуализации данных.
+- sklearn - библиотека для машинного обучения и анализа данных.
+### Что делает программа
+Программа читает данные из csv файла. Подготавливает их для работы модели, приводя текстовые параметры к числам.  И кластеризует учеников по результатам их экзаменов.  
+### Тесты
+![Кластеризация первых 15](lab4_1.png)
+  
+На примере первых пятнадцати учеников хорошо видна их кластеризация дендрограммой. Ученики легко бьются на группы по их успеваемости.  
+Благодаря этому можно выделить группы учеников в зависимости от их оценок. Достаточно выбрать необходимую ветвь.  
+  
+![Кластеризация первых 45](lab4_2.png)
+Хотя диаграмма на большее количество учеников и становиться более насыщенной. В ней всё равно достаточно просто выделить группы учеников по успеваемости.    
+  
+Вывод: Кластеризация дендрограммой позволяет достаточно эффективно делить учащихся на группы по успеваемости, основываясь на оценках их экзаменов.  

savenkov_alexander_lab_1/.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

savenkov_alexander_lab_1/.idea/.name

@@ -0,0 +1 @@
+main.py

savenkov_alexander_lab_1/.idea/Lab_1_IIS.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/venv" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

savenkov_alexander_lab_1/.idea/discord.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="DiscordProjectSettings">
+    <option name="show" value="ASK" />
+    <option name="description" value="" />
+  </component>
+</project>

savenkov_alexander_lab_1/.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

savenkov_alexander_lab_1/.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.11" project-jdk-type="Python SDK" />
+  <component name="PyCharmProfessionalAdvertiser">
+    <option name="shown" value="true" />
+  </component>
+</project>

savenkov_alexander_lab_1/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/Lab_1_IIS.iml" filepath="$PROJECT_DIR$/.idea/Lab_1_IIS.iml" />
+    </modules>
+  </component>
+</project>

savenkov_alexander_lab_1/app.py

@@ -0,0 +1,62 @@
+import numpy as np
+from flask import Flask, request, render_template
+from sklearn.datasets import make_moons
+from sklearn.linear_model import LinearRegression
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.linear_model import Ridge
+from sklearn.model_selection import train_test_split
+import matplotlib.pyplot as plt
+
+app = Flask(__name__)
+
+@app.route('/')
+def home():
+    return render_template('index.html')
+
+@app.route('/compare_models', methods=['POST'])
+def compare_models():
+    # Генерация данных
+    rs = 0
+    X, y = make_moons(noise=0.3, random_state=rs)
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=rs)
+
+    # Линейная регрессия
+    lr = LinearRegression()
+    lr.fit(X_train, y_train)
+    lr_score = lr.score(X_test, y_test)
+
+    # Полиномиальная регрессия (степень 3)
+    poly = PolynomialFeatures(degree=3)
+    X_poly = poly.fit_transform(X_train)
+    poly_reg = LinearRegression()
+    poly_reg.fit(X_poly, y_train)
+    poly_score = poly_reg.score(poly.transform(X_test), y_test)
+
+    # Гребневая полиномиальная регрессия (степень 3, alpha=1.0)
+    ridge = Ridge(alpha=1.0)
+    ridge.fit(X_poly, y_train)
+    ridge_score = ridge.score(poly.transform(X_test), y_test)
+
+    # Создание графиков
+    plt.figure(figsize=(12, 4))
+
+    plt.subplot(131)
+    plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=plt.cm.RdBu)
+    plt.title('Линейная регрессия\n(Score: {:.2f})'.format(lr_score))
+
+    plt.subplot(132)
+    plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=plt.cm.RdBu)
+    plt.title('Полиномиальная регрессия\n(Score: {:.2f})'.format(poly_score))
+
+    plt.subplot(133)
+    plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=plt.cm.RdBu)
+    plt.title('Гребневая полиномиальная регрессия\n(Score: {:.2f})'.format(ridge_score))
+
+    plt.tight_layout()
+
+    plt.savefig('static/models_comparison.png')
+
+    return render_template('index.html', result=True)
+
+if __name__ == '__main__':
+    app.run(debug=True)

savenkov_alexander_lab_1/readme.md

@@ -0,0 +1,63 @@
+Общее задание:
+Используя код из пункта «Регуляризация и сеть прямого 
+распространения» из [1] (стр. 228), сгенерируйте определенный тип данных и 
+сравните на нем 3 модели (по варианту). Постройте графики, отобразите 
+качество моделей, объясните полученные результаты.
+
+Задание по вариантам 1 вариант (22), взял 1 т.к. всего 21 вариант задания:
+1. Данные: make_moons (noise=0.3, random_state=rs) 
+Модели:
+· Линейную регрессию 
+· Полиномиальную регрессию (со степенью 3) 
+· Гребневую полиномиальную регрессию (со степенью 3, alpha = 1.0) 
+
+Запуск приложения осуществляется запуском файла app.py
+
+Использованные технологии:
+Среда программирования Pycharm
+Версия языка python: 3.11
+Flask: Flask - это микрофреймворк для создания веб-приложений на языке Python. Он используется для создания веб-сервера и определения маршрутов, таких как '/' и '/compare_models', для обработки запросов.
+
+HTML: Ваш шаблон index.html использует язык разметки HTML для создания веб-страницы и отображения содержимого на веб-сайте.
+
+Matplotlib: Matplotlib - это библиотека для создания графиков и визуализации данных. В этой программе она используется для создания трех графиков, представляющих результаты различных моделей.
+
+NumPy: NumPy - это библиотека для вычислительных операций с массивами и матрицами. В этой программе она используется для генерации данных (make_moons) и работы с данными.
+
+Scikit-Learn (sklearn): Scikit-Learn - это библиотека машинного обучения для Python. Она используется для обучения трех моделей машинного обучения: линейной регрессии, полиномиальной регрессии и гребневой полиномиальной регрессии.
+
+Jinja2: Flask использует шаблонизатор Jinja2 для вставки динамических данных (например, параметра result) в HTML-шаблоны.
+
+Файловая система и статические файлы: В программе используется файловая система для сохранения изображений графиков (static/models_comparison.png). Эти изображения затем отображаются на веб-странице как статические файлы.
+
+Краткое описание работы программы:
+В разделе HTML (index.html) определен шаблон для главной страницы. Этот шаблон содержит заголовок, форму для отправки POST-запроса на /compare_models и, если result истинно, отображает изображение графиков моделей.
+
+В Python-скрипте (app.py) создается Flask-приложение, которое имеет два маршрута:
+
+'/' отвечает за главную страницу и отображает шаблон index.html.
+'/compare_models' обрабатывает POST-запрос, обучает различные модели и создает графики. После этого он возвращает результат в виде изображений и обновляет страницу с параметром result=True, чтобы отобразить изображения.
+Для генерации данных используется make_moons, а затем данные разбиваются на обучающий и тестовый наборы.
+
+Тренируются три модели: линейная регрессия, полиномиальная регрессия (степень 3) и гребневая полиномиальная регрессия (степень 3, alpha=1.0).
+
+После обучения моделей создаются три графика, каждый из которых представляет собой точечное облако с цветной разметкой, а также заголовок, содержащий оценку (score) модели.
+
+Графики сохраняются в файл static/models_comparison.png.
+
+Наконец, приложение запускается с debug=True в режиме отладки.
+
+Пример входных данных:
+X = [[-0.5, 0.5],
+     [0.2, 1.2],
+     [1.5, -0.3],
+     ...
+     ]  # Матрица признаков
+
+y = [0, 1, 0, 1, 1, 0, 0, 1, ...]  # Вектор меток классов
+
+Пример выходных данных:
+Графики моделей: Это изображения, на которых отображены точки данных с цветной разметкой в соответствии с предсказанными значениями моделей.
+Оценки моделей: В заголовках графиков отображаются оценки моделей (например, Score: 0.85), которые показывают качество каждой модели на тестовых данных.
+
+Обновленная главная страница: После генерации графиков, главная страница (index.html) обновляется, и на ней отображаются созданные графики моделей.

savenkov_alexander_lab_1/templates/index.html

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Сравнение моделей</title>
+</head>
+<body>
+    <h1>Сравнение моделей</h1>
+    <form action="/compare_models" method="POST">
+        <button type="submit">Сравнить модели</button>
+    </form>
+    <br>
+    {% if result %}
+        <h2>Графики моделей</h2>
+        <img src="static/models_comparison.png" alt="Графики моделей">
+    {% endif %}
+</body>
+</html>

savenkov_alexander_lab_2/.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

savenkov_alexander_lab_2/.idea/.name

@@ -0,0 +1 @@
+app.py

savenkov_alexander_lab_2/.idea/Lab_2_IIS.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/venv" />
+    </content>
+    <orderEntry type="jdk" jdkName="Python 3.11" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

savenkov_alexander_lab_2/.idea/discord.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="DiscordProjectSettings">
+    <option name="show" value="ASK" />
+    <option name="description" value="" />
+  </component>
+</project>

savenkov_alexander_lab_2/.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

savenkov_alexander_lab_2/.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.11" project-jdk-type="Python SDK" />
+  <component name="PyCharmProfessionalAdvertiser">
+    <option name="shown" value="true" />
+  </component>
+</project>

savenkov_alexander_lab_2/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/Lab_2_IIS.iml" filepath="$PROJECT_DIR$/.idea/Lab_2_IIS.iml" />
+    </modules>
+  </component>
+</project>