savenkov_alexander_lab_1 is done

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

.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" />

almukhammetov_bulat_lab_2/README.md

@@ -0,0 +1,40 @@
+Вариант 2
+
+Задание:
+Используя код из [1](пункт «Решение задачи ранжирования признаков», стр.  205),  выполните  ранжирование признаков с помощью указанных по варианту моделей.  Отобразите получившиеся значения\оценки каждого признака каждым методом\моделью и среднюю оценку.  Проведите анализ получившихся результатов.  Какие четыре признака оказались самыми важными по среднему значению?  (Названия\индексы признаков и будут ответом на задание).
+
+Данные: 
+Линейная регрессия (LinearRegression)
+Рекурсивное сокращение признаков (Recursive Feature Elimination –RFE)
+Сокращение признаков Случайными деревьями (Random Forest Regressor)
+
+Запуск:
+Запустите файл lab2.py
+
+Описание программы:
+1. Генерирует случайные данные для задачи регрессии с помощью функции make_regression, создавая матрицу признаков X и вектор целевой переменной y.
+2. Создает DataFrame data, в котором столбцы представляют признаки, а последний столбец - целевую переменную.
+3. Разделяет данные на матрицу признаков X и вектор целевой переменной y.
+4. Создает список моделей для ранжирования признаков: линейной регрессии, рекурсивного сокращения признаков и сокращения признаков случайными деревьями.
+5. Создает словарь model_scores для хранения оценок каждой модели.
+6. Обучает и оценивает каждую модель на данных:
+7. Вычисляет ранги признаков и нормализует их в диапазоне от 0 до 1.
+8. Выводит оценки признаков каждой модели и их средние оценки.
+9. Находит четыре наиболее важных признака по средней оценке и выводит их индексы и значения.
+
+Результаты:
+
+![Alt text](image.png)
+
+![Alt text](image-1.png)
+
+![Alt text](image-2.png)
+
+![Alt text](image-3.png)
+
+![Alt text](image-4.png)
+
+Выводы: 
+
+Четыре наиболее важных признака, определенных на основе средних оценок, включают Признак 6, Признак 1, Признак 2 и Признак 5. Эти признаки имеют наибольшую среднюю важность среди всех признаков.
+

almukhammetov_bulat_lab_2/lab2.py

@@ -0,0 +1,75 @@
+import numpy as np
+import pandas as pd
+from sklearn.datasets import make_regression
+from sklearn.linear_model import LinearRegression
+from sklearn.feature_selection import RFE
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.preprocessing import MinMaxScaler
+
+# Используя код из [1](пункт «Решение задачи ранжирования признаков», стр.  205),  выполните  ранжирование признаков
+# с помощью указанных по варианту моделей.  Отобразите получившиеся значения\оценки каждого признака каждым
+# методом\моделью и среднюю оценку.  Проведите анализ получившихся результатов.  Какие четыре признака оказались
+# самыми важными по среднему значению?  (Названия\индексы признаков и будут ответом на задание).
+
+# Линейная регрессия (LinearRegression), Рекурсивное сокращение признаков (Recursive Feature Elimination –RFE),
+# Сокращение признаков Случайными деревьями (Random Forest Regressor)
+random_state = np.random.RandomState(2)
+
+# Генерация случайных данных для регрессии
+X, y = make_regression(n_samples=100, n_features=10, noise=0.1, random_state=random_state)
+
+# Создание DataFrame для данных
+data = pd.DataFrame(X, columns=[f'признак_{i}' for i in range(X.shape[1])])
+data['целевая_переменная'] = y
+
+# Разделение данных на признаки (X) и целевую переменную (y)
+X = data.drop('целевая_переменная', axis=1)
+y = data['целевая_переменная']
+
+# Создаем модели
+models = [
+    ("Линейная регрессия", LinearRegression()),
+    ("Рекурсивное сокращение признаков", RFE(LinearRegression(), n_features_to_select=1)),
+    ("Сокращение признаков Случайными деревьями", RandomForestRegressor())
+]
+
+# Словарь для хранения оценок каждой модели
+model_scores = {}
+
+# Обучение и оценка моделей
+for name, model in models:
+    model.fit(X, y)
+    if name == "Рекурсивное сокращение признаков":
+        # RFE возвращает ранжирование признаков
+        rankings = model.ranking_
+        # Нормализация рангов так, чтобы они находились в диапазоне от 0 до 1
+        normalized_rankings = 1 - (rankings - 1) / (np.max(rankings) - 1)
+        model_scores[name] = normalized_rankings
+    elif name == "Сокращение признаков Случайными деревьями":
+        # Важность признаков для RandomForestRegressor
+        feature_importances = model.feature_importances_
+        # Нормализация значений важности признаков в диапазоне от 0 до 1
+        normalized_importances = MinMaxScaler().fit_transform(feature_importances.reshape(-1, 1))
+        model_scores[name] = normalized_importances.flatten()
+    elif name == "Линейная регрессия":
+        # Коэффициенты признаков для Linear Regression
+        coefficients = model.coef_
+        # Нормализация коэффициентов так, чтобы они находились в диапазоне от 0 до 1
+        normalized_coefficients = MinMaxScaler().fit_transform(np.abs(coefficients).reshape(-1, 1))
+        model_scores[name] = normalized_coefficients.flatten()
+
+# Вывод оценок каждой модели
+for name, scores in model_scores.items():
+    print(f"{name} оценки признаков:")
+    for feature, score in enumerate(scores, start=1):
+        print(f"Признак {feature}: {score:.2f}")
+    print(f"Средняя оценка: {np.mean(scores):.2f}")
+    print()
+
+# Находим четыре наиболее важных признака по средней оценке
+all_feature_scores = np.mean(list(model_scores.values()), axis=0)
+sorted_features = sorted(enumerate(all_feature_scores, start=1), key=lambda x: x[1], reverse=True)
+top_features = sorted_features[:4]
+print("Четыре наиболее важных признака:")
+for feature, score in top_features:
+    print(f"Признак {feature}: {score:.2f}")

antonov_dmitry_lab_2/README.md

@@ -0,0 +1,84 @@
+# Лаб 2
+
+Ранжирование признаков
+
+Выполните ранжирование признаков с помощью указанных по варианту моделей. 
+Отобразите получившиеся значения\оценки каждого признака каждым методом\моделью и среднюю оценку. 
+Проведите анализ получившихся результатов. 
+Какие четыре признака оказались самыми важными по среднему значению? 
+(Названия\индексы признаков и будут ответом на задание).
+
+# Вариант 3
+
+Линейная регрессия (LinearRegression) , Сокращение признаков
+Случайными деревьями (Random Forest Regressor), Линейная корреляция
+(f_regression)
+
+Я использовал датасет Predict students' dropout and academic success
+https://www.kaggle.com/datasets/thedevastator/higher-education-predictors-of-student-retention
+Он используется мной по заданию на курсовую работу
+
+# Запуск
+
+Выполнением скрипта файла (вывод в консоль).
+
+# Модели:
+
+1. Линейная регрессия (LinearRegression)
+1. Сокращение признаков cлучайными деревьями (Random Forest Regressor)
+1. Линейная корреляция (f_regression)
+
+# Пояснения
+
+<div>
+Выбор наиболее подходящего метода ранжирования объектов зависит от специфики набора данных и требований 
+к модели.
+
+Линейная регрессия - это простой и понятный метод, который может быть использован для предсказания значений.
+Он хорошо работает, если зависимость между переменными является линейной. 
+Однако, если данные содержат сложные нелинейные зависимости, линейная регрессия может 
+оказаться не очень эффективной.
+
+Уменьшение признаков с помощью случайных деревьев (Random Forest Regressor) - это мощный метод, 
+который способен обрабатывать сложные взаимосвязи в данных, даже если они нелинейные. 
+Он основан на идее создания ансамбля деревьев решений, каждое из которых дает свой голос за 
+наиболее подходящий ответ. Случайные леса обычно дают хорошие результаты и являются устойчивыми 
+к переобучению.
+
+Линейная корреляция или f_regression - это статистический метод, который используется для измерения 
+степени связи между двумя переменными. Он может помочь определить, есть ли вообще связь между переменными, 
+но не подходит для ранжирования объектов.
+</div>
+
+### 4 самых важных признака в среднем:
+1. Признак: Curricular units 2nd sem (approved), Оценка: 0.8428
+2. Признак: Tuition fees up to date, Оценка: 0.4797
+3. Признак: Curricular units 1st sem (approved), Оценка: 0.2986
+4. Признак: Curricular units 2nd sem (grade), Оценка: 0.2778
+
+### 4 самых важных для lr_scores линейной регрессии:
+1. 0.3917 'Tuition fees up to date'
+2. 0.2791 'International'
+3. 0.2075 'Curricular units 2nd sem (approved)'
+4. 0.1481 'Debtor'
+
+### 4 самых важных для rf_scores рандом forests:
+1. 0.4928 'Curricular units 2nd sem (approved)'
+2. 0.061 'Tuition fees up to date'
+3. 0.0458 'Curricular units 2nd sem (grade)'
+4. 0.0308 'Curricular units 1st sem (grade)'
+
+### 4 самых важных для f_regression:
+1. 2822.104 'Curricular units 2nd sem (approved)'
+2. 2093.3315 'Curricular units 2nd sem (grade)'
+3. 1719.4229 'Curricular units 1st sem (approved)'
+4. 1361.6144 'Curricular units 1st sem (grade)'
+
+### Объяснение:
+<div>
+В общем, выбор между линейной регрессией и случайными лесами зависит от характеристик данных. 
+Если данные имеют линейную зависимость, то линейная регрессия будет предпочтительнее.
+Если данные содержат сложные, возможно нелинейные взаимосвязи, то Random Forest может быть лучшим выбором. 
+В любом случае, важно провести предварительное исследование данных и тестирование различных моделей, 
+чтобы выбрать наиболее подходящую.
+</div>

antonov_dmitry_lab_2/lab2.py

@@ -0,0 +1,106 @@
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.feature_selection import f_regression
+from sklearn.preprocessing import MinMaxScaler
+
+# загрузка dataset
+data = pd.read_csv('dataset.csv')
+
+# разделение dataset на тренировочную и тестовую выборки
+X = data.drop(['Target'], axis=1)
+y = data['Target']
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Тренировка моделей
+# Линейная регрессия
+lr = LinearRegression()
+lr.fit(X_train, y_train)
+
+# Сокращение признаков случайными деревьями с помощью Random Forest Regressor
+rf = RandomForestRegressor()
+rf.fit(X_train, y_train)
+
+# Ранжирование признаков использую каждую модель/метод
+# Получение абсолютных значений коэффициентов в качестве оценок важности признаков
+lr_scores = abs(lr.coef_)
+
+# Получение оценок важности объектов из модели Random Forest Regressor
+rf_scores = rf.feature_importances_
+
+# Отображение итоговых оценок по каждой колонке
+feature_names = X.columns.tolist()
+
+# показать оценки рангов по модели линейной регрессии
+print("оценки линейной регрессии:")
+for feature, score in zip(feature_names, lr_scores):
+    print(f"{feature}: {round(score, 4)}")
+
+# оценки метода рандомных лесов
+print("\nоценки Random Forest:")
+for feature, score in zip(feature_names, rf_scores):
+    print(f"{feature}: {round(score, 4)}")
+
+# вычисление значений оценки для f_regression
+f_scores, p_values = f_regression(X, y)
+
+# оценки f_regression
+print("\nоценки f_regression:")
+for feature, score in zip(feature_names, f_scores):
+    print(f"{feature}: {round(score, 4)}")
+
+# использую MinMaxScaler для точных средних значений рангов
+scaler = MinMaxScaler()
+lr_scores_scaled = scaler.fit_transform(lr_scores.reshape(-1, 1)).flatten()
+rf_scores_scaled = scaler.fit_transform(rf_scores.reshape(-1, 1)).flatten()
+f_scores_scaled = scaler.fit_transform(f_scores.reshape(-1, 1)).flatten()
+
+# вычисление средних оценок для каждого признака
+average_scores = {}
+for feature in feature_names:
+    average_scores[feature] = (lr_scores_scaled[feature_names.index(feature)] +
+                              rf_scores_scaled[feature_names.index(feature)] +
+                              f_scores_scaled[feature_names.index(feature)]) / 3
+
+# получаем среднюю оценку признаков
+sorted_features = sorted(average_scores.items(), key=lambda x: x[1], reverse=True)
+
+# получаем самых важных признака
+top_4_features = sorted_features[:4]
+
+# отображаем 4 самые важные
+print("\n4 самых важных признака в среднем:")
+for feature, score in top_4_features:
+    print(f"Признак: {feature}, Оценка: {round(score, 4)}")
+
+
+# отображаем самых важных признака для каждого метода/модели
+top_lr_indices = np.argsort(lr_scores)[-4:][::-1]
+top_rf_indices = np.argsort(rf_scores)[-4:][::-1]
+top_f_indices = np.argsort(f_scores)[-4:][::-1]
+
+top_lr_features = [feature_names[i] for i in top_lr_indices]
+top_rf_features = [feature_names[i] for i in top_rf_indices]
+top_f_features = [feature_names[i] for i in top_f_indices]
+
+top_lr_features_score = [lr_scores[i] for i in top_lr_indices]
+top_rf_features_score = [rf_scores[i] for i in top_rf_indices]
+top_f_features_score = [f_scores[i] for i in top_f_indices]
+
+print("\n4 самых важных для lr_scores:")
+print(top_lr_features)
+for i in top_lr_features_score:
+    print(round(i, 4))
+
+print("\n4 самых важных для rf_scores:")
+print(top_rf_features)
+for i in top_rf_features_score:
+    print(round(i, 4))
+
+print("\n4 самых важных для f_scores:")
+print(top_f_features)
+for i in top_f_features_score:
+    print(round(i, 4))

antonov_dmitry_lab_4/README.md

@@ -0,0 +1,78 @@
+# Лаб 4 Кластеризация
+
+Использовать метод кластеризации по варианту для данных из датасета курсовой
+Predict students' dropout and academic success (отсев студентов), самостоятельно сформулировав задачу.
+Интерпретировать результаты и оценить, насколько хорошо он подходит для
+решения сформулированной вами задачи.
+
+# Вариант 3
+
+Метод t-SNE
+
+# Запуск
+
+Выполнением скрипта файла (вывод в консоль).
+
+# Описание модели:
+
+T-Distributed Stochastic Neighbor Embedding (t-SNE) - это метод визуализации и снижения размерности, 
+используемый для визуализации многомерных данных в виде двумерной или трехмерной графики.
+
+Результатом работы t-SNE является визуализация данных, где близкие точки в исходном пространстве отображаются 
+близко друг к другу, а отдаленные точки - далеко. Это позволяет исследователям изучать структуру данных и 
+находить кластеры и структуры, которые могут быть не видны при прямом наблюдении исходного пространства высокой размерности.
+
+# Задача кластеризации
+Учитывая набор данных, содержащий информацию о студентах, включая их пол, международный статус и ВВП, 
+цель состоит в том, чтобы сгруппировать этих студентов в отдельные кластеры на основе этих признаков. 
+Цель состоит в том, чтобы выявить естественные закономерности или подгруппы среди учащихся, которые могут 
+иметь сходные характеристики с точки зрения пола, международного статуса и экономического происхождения. 
+Такая кластеризация может помочь в адаптации образовательных программ, служб поддержки или вмешательств 
+к конкретным группам учащихся для улучшения академических результатов и показателей удержания. 
+Цель анализа - выявить значимые идеи, которые могут быть использованы для улучшения общего образовательного опыта 
+и показателей успешности различных групп учащихся.
+
+# Результаты
+
+Для применения метода уменьшения размерности t-SNE использованы признаки "Гендер", "Международный" и "ВВП".
+Данные проецируются на двумерную плоскость, при этом сохраняя локальную структуру данных.
+
+Как интерпретировать результаты на графике:
+
+1. Пол:
+   - Поскольку "Пол" является категориальной переменной (бинарной, как "Мужчина" или "Женщина"), 
+   - Ожидается увидеть на графике отчетливые кластеры или разделения. Каждая точка представляет учащегося, 
+   - и лица одинакового пола должны быть сгруппированы вместе.
+
+2. Международный:
+   - "Международный" также является бинарной категориальной переменной (например, "Да" или "Нет" указывает, 
+   - является ли студент иностранным), вы можете увидеть разделение между иностранными и немеждународными студентами. 
+   - Это может привести к образованию двух различных кластеров.
+
+3. ВВП:
+   - "ВВП" - это непрерывная переменная, и ее значения будут представлены в виде точек на графике. В зависимости от 
+   - распределения значений ВВП вы можете наблюдать градиент или закономерность в данных.
+
+Теперь, когда посмотреть на график, должны быть видны точки, разбросанные по двумерному пространству. Похожие точки 
+находятся близко друг к другу, а непохожие - дальше друг от друга.
+
+- Результаты:
+  - Видны четкие кластеры, это говорит о том, что эти признаки являются хорошими показателями для разделения 
+  - студентов на группы.
+  
+  - Доминирующими признаками являются "гендер" и "Интернациональность", можно увидеть два различных кластера, 
+  - в одном из которых, например, в основном учатся местные студенты мужского пола, а в другом - иностранные студентки 
+  - женского пола.
+
+  - "ВВП" оказывает сильное влияние, можно увидеть градиент точек, указывающий на корреляцию между ВВП и 
+  - некоторой базовой закономерностью в данных.
+
+Конкретная интерпретация будет зависеть от фактического распределения и характеристик данных. 
+Также важно отметить, что t-SNE - это стохастический алгоритм, поэтому его многократное выполнение с одними и теми 
+же параметрами может привести к несколько иным результатам. Поэтому рекомендуется изучить графики из нескольких прогонов, 
+чтобы получить четкое представление о структуре данных.
+
+<p>
+    <div>График</div>
+    <img src="screens/myplot.png" width="650" title="График">
+</p>

antonov_dmitry_lab_4/lab4.py

@@ -0,0 +1,22 @@
+import pandas as pd
+from sklearn.cluster import KMeans
+from sklearn.manifold import TSNE
+import matplotlib.pyplot as plt
+
+# загрузка датасета
+data = pd.read_csv('dataset.csv')
+
+# выделение необходимых признаков
+X = data[['Gender', 'International', 'GDP']]
+
+# применение t-SNE для сокращения размерности
+tsne = TSNE(n_components=2, random_state=42)
+X_tsne = tsne.fit_transform(X)
+
+# визуализация данных
+plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=data['Target'], cmap='viridis')
+plt.colorbar()
+plt.xlabel('t-SNE х')
+plt.ylabel('t-SNE у')
+plt.title('t-SNE визуализация')
+plt.show()

antonov_dmitry_lab_5/README.md

@@ -0,0 +1,42 @@
+# Лаб 5 Регрессия
+
+Использовать регрессию по варианту для данных из датасета курсовой
+Predict students' dropout and academic success (отсев студентов), 
+самостоятельно сформулировав задачу. Оценить, насколько хорошо она подходит 
+для решения сформулированной вами задачи.
+
+# Вариант 3
+
+Лассо-регрессия
+
+# Запуск
+
+Выполнением скрипта файла (вывод в консоль).
+
+# Описание модели:
+
+Лассо (Lasso) — это метод регрессионного анализа, который используется в статистике и 
+машинном обучении для предсказания значения зависимой переменной. 
+
+Регрессия Лассо использует регуляризацию L1 для добавления штрафа, равного абсолютному 
+значению коэффициентов. Это уменьшает некоторые коэффициенты и устанавливает другие равными 0, 
+выполняя автоматический выбор функции. Обычная регрессия не имеет регуляризации.
+
+# Задача регрессии
+Для прогнозирования отсева учащихся и набора данных об успеваемости спрогнозируйте отсев 
+используя регрессию Лассо для признаков
+'Curricular units 2nd sem (approved)' - (Учебные блоки 2-го семестра (утверждены))
+'Curricular units 2nd sem (grade)' - (Учебные блоки 2-го семестра (класс))
+'Tuition fees up to date' - (Стоимость обучения")
+
+# Результаты
+Точность регрессии для вышеперечисленных признаков составили 0.6256 (alpha = 0.01)
+При изменении коэффициента регуляризации в диапозоне от 0.01 до 1.5 наблюдается только ухудшение качества 
+модели, таким образом для заданных параметров подходит больше обычная модель линейной регрессии, так как
+по этим признакам судя по результатам наблюдается линейная зависимость.
+Для этих признаков модель регрессии подходит плохо, нужно искать другую.
+
+<p>
+    <div>График</div>
+    <img src="screens/myplot.png" width="650" title="График">
+</p>

antonov_dmitry_lab_5/lab5.py

@@ -0,0 +1,47 @@
+import numpy as np
+import pandas as pd
+from matplotlib import pyplot as plt
+from sklearn.linear_model import Lasso
+from sklearn.metrics import accuracy_score
+from sklearn.model_selection import train_test_split
+
+# загрузка данных
+data = pd.read_csv('dataset.csv')
+X = (data[
+         ['Curricular units 2nd sem (approved)',
+          'Tuition fees up to date',
+          'Curricular units 2nd sem (grade)']]
+)
+y = data['Target']
+
+# тренировка модели
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+lasso_model = Lasso(alpha=0.01)
+lasso_model.fit(X_train, y_train)
+
+# оценка модели
+y_pred_train = lasso_model.predict(X_train)
+y_pred_test = lasso_model.predict(X_test)
+
+# оценка результатов модели
+train_accuracy = accuracy_score(y_train, np.round(y_pred_train))
+test_accuracy = accuracy_score(y_test, np.round(y_pred_test))
+
+# вывод результатов
+print(f"Тренировочная Accuracy: {train_accuracy}")
+print(f"Тест Accuracy: {test_accuracy}")
+
+# коэффициенты значимости признаков
+coefficients = lasso_model.coef_
+feature_names = X.columns
+
+# вывод в консоль коэффициентов значимости
+for feature, coef in zip(feature_names, coefficients):
+    print(f"{feature}: {coef}")
+
+plt.figure(figsize=(10, 6))
+plt.barh(feature_names, coefficients)
+plt.xlabel('коэффициент')
+plt.title('Значимости признаков по регрессии Лассо')
+plt.show()

antonov_dmitry_lab_6/README.md

@@ -0,0 +1,89 @@
+# Лаб 6 Нейронная сеть
+
+Использовать нейронную сеть MLPClassifier по варианту для данных из датасета курсовой
+Predict students' dropout and academic success (отсев студентов), 
+самостоятельно сформулировав задачу. Оценить, насколько хорошо она подходит 
+для решения сформулированной вами задачи.
+
+# Вариант 3
+
+Нейронная сеть MLPClassifier
+
+# Запуск
+
+Выполнением скрипта файла (вывод в консоль).
+
+# Задача регрессии
+Для прогнозирования отсева учащихся и набора данных об успеваемости спрогнозируйте отсев 
+используя нейронную сеть для признаков
+'Curricular units 2nd sem (approved)' - (Учебные блоки 2-го семестра (утверждены))
+'Curricular units 2nd sem (grade)' - (Учебные блоки 2-го семестра (класс))
+'Tuition fees up to date' - (Стоимость обучения")
+
+# Описание модели:
+"MLPClassifier" - это тип искусственной нейронной сети прямого действия, которая широко используется для задач классификации. 
+Объяснение некоторых ключевых параметров:
+
+1. hidden_layer_sizes:
+- Этот параметр определяет количество нейронов в каждом скрытом слое и количество скрытых слоев в сети. 
+- Это кортеж, где каждый элемент представляет количество нейронов в определенном скрытом слое.
+- Например, `hidden_layer_sizes=(100, 100)` означает, что есть два скрытых слоя, причем первый слой 
+- содержит 100 нейронов, а второй слой также содержит 100 нейронов.
+
+2. activation:
+- Этот параметр определяет функцию активации для скрытых слоев. Функция активации привносит 
+нелинейность в сеть, позволяя ей изучать сложные паттерны.
+- Распространенные варианты включают:
+- "identity": линейная функция активации (обычно не используется на практике).
+- "logistic": сигмовидная логистическая функция
+- "tanh": гиперболическая касательная функция
+- "relu": Выпрямленная линейная единица измерения
+
+3. solver:
+- Этот параметр определяет алгоритм, используемый для оптимизации весов нейронной сети.
+- Распространенные варианты включают:
+- `adam": оптимизатор на основе стохастического градиента, сочетающий идеи RMSProp и Momentum.
+- `sgd": Стохастический градиентный спуск.
+- `lbfgs": алгоритм Бройдена-Флетчера-Гольдфарба-Шанно с ограниченной памятью.
+
+4. alpha:
+- Параметр штрафа L2 (условие регуляризации). Это помогает предотвратить переобучение, 
+наказывая за большие веса.
+- Более высокие значения "альфа" приводят к более сильной регуляризации.
+
+5. max_iter:
+- Максимальное количество итераций для тренировочного процесса. Этот параметр помогает 
+предотвратить бесконечное обучение модели.
+
+6. learning_rate:
+- График скорости обучения для обновления веса. Он определяет размер шага, с которым веса 
+обновляются во время тренировки.
+- Опции включают 'constant', 'invscaling', и 'adaptive'.
+
+7. random_state:
+- Начальное значение, используемое генератором случайных чисел. Установка начального значения 
+гарантирует воспроизводимость результатов.
+
+8. batch_size:
+- Количество образцов, использованных в каждой мини-партии во время обучения. Это влияет 
+на скорость конвергенции и использование памяти.
+
+9. early_stopping:
+- Если установлено значение "True", обучение прекратится, если оценка проверки не улучшится. 
+Это помогает предотвратить переобучение.
+
+10. validation_fraction:
+- Доля обучающих данных, которую следует отложить в качестве валидационного набора для ранней 
+остановки.
+
+# Результат:
+Из прошлой лабораторной точность регрессии для вышеперечисленных признаков составила 0.6256 (alpha = 0.01)
+Точность нейронной сети для вышеперечисленных признаков составила 72.32%
+(при изменении описанных выше параметров оценка не улучается)
+На примере тех же самых признаков нейронная сеть обеспечивает 
+лучшее качество предсказания отсева студентов.
+
+<p>
+    <div>Результат</div>
+    <img src="screens/img.png" width="650" title="Результат">
+</p>

antonov_dmitry_lab_6/lab6.py

@@ -0,0 +1,51 @@
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.neural_network import MLPClassifier
+from sklearn.preprocessing import StandardScaler
+
+# загрузка датасета
+data = pd.read_csv('dataset.csv')
+
+# выбор признаков
+features = [
+    'Curricular units 2nd sem (approved)',
+    'Curricular units 2nd sem (grade)',
+    'Tuition fees up to date',
+    ]
+target = 'Target'
+
+X = data[features]
+y = data[target]
+
+# разбиваем на тестовую и тренировочную выборки
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# стандартизация признаков
+scaler = StandardScaler()
+X_train = scaler.fit_transform(X_train)
+X_test = scaler.transform(X_test)
+
+# тренируем нейронную сеть MLPClassifier
+classifier = MLPClassifier(
+    hidden_layer_sizes=(50, 50),  # два скрытых слоя с 50 нейронами каждый
+    activation='relu',              # relu функция активации
+    solver='adam',                  # оптимизатор на основе стохастического градиента
+    alpha=0.0001,                    # L2 штраф (регуляризация)
+    max_iter=1000,                   # макс итераций
+    learning_rate='constant',        # постоянная скорость обучения
+    random_state=42,                # Random начало для воспроизведения результата
+    batch_size=32,                   # размер мини партии
+    early_stopping=True,             # для предотвращения переобучения
+    validation_fraction=0.2,        # 20% данных для проверки
+    verbose=True,                   # для оттображения итераций
+)
+classifier.fit(X_train, y_train)
+
+# предсказываем значение
+y_pred = classifier.predict(X_test)
+
+# оцениваем результат
+accuracy = np.mean(y_pred == y_test)
+
+print(f'Оценка точности: {accuracy*100:.2f}%')

belyaeva_ekaterina_lab_1/README.md

@@ -0,0 +1,49 @@
+## Задание
+
+Вариант 6:
+
+Данные: make_classification (n_samples=500, n_features=2, n_redundant=0, n_informative=2, 
+random_state=rs, n_clusters_per_class=1) 
+
+Модели:
+
+· Линейную регрессию  
+· Полиномиальную регрессию (со степенью 4)  
+· Гребневую полиномиальную регрессию(со степенью 4, alpha= 1.0)
+
+## Как запустить лабораторную
+
+Запустить файл main.py
+
+## Используемые технологии
+
+Библиотеки matplotlib, scikit-learn, их компоненты, все описано ниже
+
+## Описание лабораторной (программы)
+
+Программа генерирует набор данных с помощью функции make_classification с параметрами из задания  
+Далее происходит разделение данных на обучащей и тестовый наборы с помощью функции train_test_split  
+Потом происходит обучение моделей на тестовой выборке  
+И предсказание уже на данных, которые остались  
+В конце программа строит графики, отображающие данные в задании модели и выводит в консоль оценку их работы
+
+## Результат
+
+В результате программа выводит графики, скриншоты которых находятся в репозитории, а также оценки производительности обучения, полученные через model.score:  
+Линейная регрессия: 0.92  
+Полиномиальная регрессия: 0.96  
+Гребневая полиномиальная регрессия: 0.7958276459808132  
+Из результата видно, что наиболее качественной для решения данной задачи оказалась полиномиальная регрессия, наименее - гребневая полиномиальная
+  
+После полученных результатов я решила провести несколько тестов и вот что из этого вышло:   
+  
+Если поменять test_size c 0.8 на 0.2, то результат работы моделей ухудшится, и чем хуже он был до этого, тем еще более хуже стал  
+Линейная регрессия: 0.8725  
+Полиномиальная регрессия: 0.955  
+Гребневая полиномиальная регрессия: 0.6678458571780717
+
+Если изменить количество samples с 500 на 2500, то результат работы моделей значительно улучшится:  
+Линейная регрессия: 0.996  
+Полиномиальная регрессия: 0.998  
+Гребневая полиномиальная регрессия: 0.9701030991054763  
+Несмотря на это, по качеству модели выстроены все в том же порядке, что и при вводе дефолтных данных, хотя по результату все они решают задачу достаточно хорошо при получении достаточного количества данных

belyaeva_ekaterina_lab_1/main.py

@@ -0,0 +1,74 @@
+import matplotlib.pyplot as plt
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.pipeline import make_pipeline
+from sklearn.linear_model import Ridge
+
+# Задаем параметры генерации данных
+n_samples = 500
+n_features = 2
+n_redundant = 0
+n_informative = 2
+random_state = 42
+n_clusters_per_class = 1
+
+# Генерируем данные
+X, y = make_classification(n_samples=n_samples, n_features=n_features, n_redundant=n_redundant,
+                            n_informative=n_informative, random_state=random_state,
+                            n_clusters_per_class=n_clusters_per_class)
+
+# Делаем разделение на обучающую и тестовую выборки
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.8, random_state=random_state)
+
+# Обучение моделей
+# Линейная регрессия
+linear_regression = LogisticRegression()
+linear_regression.fit(X_train, y_train)
+linear_regression_score = linear_regression.score(X_train, y_train)
+
+# Полиномиальная регрессия со степенью 4
+poly_regression = make_pipeline(PolynomialFeatures(degree=4), LogisticRegression())
+poly_regression.fit(X_train, y_train)
+polynomial_regression_score = poly_regression.score(X_train, y_train)
+
+# Гребневая полиномиальная регрессия со степенью 4 и alpha = 1.0
+ridge_regression = make_pipeline(PolynomialFeatures(degree=4), Ridge(alpha=1.0))
+ridge_regression.fit(X_train, y_train)
+ridge_regression_score = ridge_regression.score(X_train, y_train)
+
+# Предсказание на тестовом наборе
+linear_pred = linear_regression.predict(X_test)
+poly_pred = poly_regression.predict(X_test)
+ridge_pred = ridge_regression.predict(X_test)
+
+# Построение графиков
+plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap="bwr")
+plt.title("График исходных данных")
+plt.xlabel("Признак 1")
+plt.ylabel("Признак 2")
+plt.show()
+
+plt.scatter(X_test[:, 0], X_test[:, 1], c=linear_pred, cmap="bwr")
+plt.title("График предсказаний линейной регрессии")
+plt.xlabel("Признак 1")
+plt.ylabel("Признак 2")
+plt.show()
+
+plt.scatter(X_test[:, 0], X_test[:, 1], c=poly_pred, cmap="bwr")
+plt.title("График предсказаний полиномиальной регрессии")
+plt.xlabel("Признак 1")
+plt.ylabel("Признак 2")
+plt.show()
+
+plt.scatter(X_test[:, 0], X_test[:, 1], c=ridge_pred, cmap="bwr")
+plt.title("График предсказаний гребневой полиномиальной регрессии")
+plt.xlabel("Признак 1")
+plt.ylabel("Признак 2")
+plt.show()
+
+print("Результаты моделей:")
+print("Линейная регрессия: {}".format(linear_regression_score))
+print("Полиномиальная регрессия: {}".format(polynomial_regression_score))
+print("Гребневая полиномиальная регрессия: {}".format(ridge_regression_score))

martysheva_tamara_lab_1/README.md

@@ -0,0 +1,46 @@
+# Лабораторная работа 1. Работа с типовыми наборами данных и различными моделями
+### Вариант № 18
+Используя код из пункта «Регуляризация и сеть прямого распространения», сгенерируйте определенный тип данных и сравните на нем 3 модели (по варианту). Постройте графики, отобразите качество моделей, объясните полученные результаты.
+
+**Данные**: make_classification (n_samples=500, n_features=2, n_redundant=0, n_informative=2, random_state=rs, n_clusters_per_class=1)
+
+**Модели**:
+* Линейную регрессию
+* Персептрон
+* Гребневую полиномиальную регрессию (со степенью 3, alpha = 1.0) 
+***
+## *Как запустить лабораторную работу:*
+Чтобы запустить программу, открываем файл lab1 в PyCharm и нажимаем на зеленый треугольник в правом верхнем углу.
+***
+## *Использованные технологии:*
+**Scikit-learn** - один из наиболее широко используемых пакетов Python для Data Science и Machine Learning. Он позволяет выполнять множество операций и предоставляет множество алгоритмов.
+
+**Matplotlib** — это комплексная библиотека для создания статических, анимированных и интерактивных визуализаций на Python.
+
+**NumPy** — это фундаментальный пакет для научных вычислений на Python.
+***
+## *Что делает ЛР:*
+В данной работе генерируется определенный тип данных (при помощи генератора линейных задач make_classification). На данном типе данных проверяется работа трёх моделей: линейная регрессия, персептрон и гребневая полиномиальная регрессия. 
+
+**Результатом работы программы** являются: вывод показателей качества моделей (в консоли) и 3 изображения с графиками, на которых показаны сами данные, разбитые на два класса (тренировочные и тестовые), а также разбиение по классам по моделям.
+***
+## *Пример выходных данных:*
+>Вывод в консоли:
+
+![](https://sun9-27.userapi.com/impg/Xc_p5nTj7wWRVxuKx8PXcvnnJcPRYXM5PijZsA/bQJSoWPqZqo.jpg?size=602x76&quality=96&sign=5797d8960621a547a08ba7bdc1e83965&type=album)
+
+>График линейной регрессии:
+
+![](https://sun9-28.userapi.com/impg/DaF38aVW1XXfrsbt8d1eNYgyssVpffN3kgZTpA/UvJiTp6ACW0.jpg?size=604x423&quality=96&sign=74a0543fa50da772fc72214c6d695e81&type=album)
+
+>График персептрона:
+
+![](https://sun9-72.userapi.com/impg/6NLpLzpUvR5EVGIy2kPAwLWp7TGjUZWdL3Jb2w/Pbu6IPLsUuc.jpg?size=604x423&quality=96&sign=83e2340b57fe60de0adda95fe1ad686d&type=album)
+
+>График гребневой полиномиальной регрессии:
+
+![](https://sun9-27.userapi.com/impg/DzhYdeV18GWPbay__0W88Zg6oEDipT62zVB2Og/k5SfwXDyKhU.jpg?size=604x423&quality=96&sign=a6c08a960b55b6aec9aa0aa2307d1978&type=album)
+***
+**Вывод**: Для сгенерированного типа данных лучшей моделью оказалась модель персептрона (с точностью 0.795), а худшей модель линейной регрессии (с точностью 0.44). 
+Персептрон может хорошо работать в задачах классификации, если данные хорошо разделимы линейно. Гребневая полиномиальная регрессия показала среднюю точность. 
+Дополнительно в данные был добавлен случайный шум, что тоже могло повлиять на результаты оценки качества моделей. 

martysheva_tamara_lab_1/lab1.py

@@ -0,0 +1,57 @@
+import numpy as np
+from sklearn.datasets import make_classification
+from sklearn.preprocessing import StandardScaler
+from sklearn.model_selection import train_test_split
+from matplotlib.colors import ListedColormap
+from matplotlib import pyplot as plt
+from sklearn.linear_model import LinearRegression, Perceptron, Ridge
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.pipeline import Pipeline
+
+#Создаем набор данных
+X, Y = make_classification(n_samples=500, n_features=2, n_redundant=0, n_informative=2, random_state=0, n_clusters_per_class=1)
+rng = np.random.RandomState(2)
+X += 2 * rng.uniform(size=X.shape)
+X = StandardScaler().fit_transform(X)
+X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=.4, random_state=40)
+
+#Создаем модели
+linear = LinearRegression()
+perseptron = Perceptron()
+ridge = Ridge(alpha=1.0)
+polynomial_features = PolynomialFeatures(degree=3)
+rid_poly = Pipeline([("polynomial_features", polynomial_features),("ridge_regression", ridge)])
+
+#Тренируем модель
+def train(model, description):
+    model.fit(X_train, Y_train)
+    Y_pred = model.predict(X_test)
+    print(description + ", качество модели = ", model.score(X_test, Y_test))
+
+#Выводим результат на график
+def plot(model, name):
+    cmap = ListedColormap(['#8b00ff', '#ff294d'])
+    plt.figure(figsize=(10, 7))
+    subplot = plt.subplot(111)
+    h = .5  # шаг регулярной сетки
+    x0_min, x0_max = X[:, 0].min() - .5, X[:, 0].max() + .5
+    x1_min, x1_max = X[:, 1].min() - .5, X[:, 1].max() + .5
+    xx0, xx1 = np.meshgrid(np.arange(x0_min, x0_max, h), np.arange(x1_min, x1_max, h))
+
+    Z = model.predict(np.c_[xx0.ravel(), xx1.ravel()])
+    Z = Z.reshape(xx0.shape)
+    subplot.contourf(xx0, xx1, Z, cmap=cmap, alpha=.3)
+
+    subplot.scatter(X_train[:, 0], X_train[:, 1], c=Y_train, cmap=cmap)
+    subplot.scatter(X_test[:, 0], X_test[:, 1], c=Y_test, cmap=cmap, alpha=0.4)
+
+    plt.savefig(name + ".png")
+
+#Вызов функций
+train(linear, "Линейная регрессия")
+train(perseptron, "Персептрон")
+train(rid_poly, "Гребневая полиномиальная регрессия")
+
+plot(linear, "linear_plot")
+plot(perseptron, "perseptron_plot")
+plot(rid_poly, "rid_poly_plot")

martysheva_tamara_lab_2/README.md

@@ -0,0 +1,49 @@
+# Лабораторная работа 2. Ранжирование признаков
+### Вариант № 18
+Используя код из пункта «Решение задачи ранжирования признаков», 
+выполните ранжирование признаков с помощью указанных по
+варианту моделей. Отобразите получившиеся оценки каждого
+признака каждой моделью и среднюю оценку. Проведите анализ
+получившихся результатов. Какие четыре признака оказались самыми
+важными по среднему значению? (Названия\индексы признаков и будут
+ответом на задание). 
+
+**Модели**:
+* Лассо (Lasso)
+* Рекурсивное сокращение признаков (Recursive Feature Elimination – RFE)
+* Линейная корреляция (f_regression)
+***
+## *Как запустить лабораторную работу:*
+Чтобы запустить программу, открываем файл lab2 в PyCharm и нажимаем на зеленый треугольник в правом верхнем углу.
+***
+## *Использованные технологии:*
+**Scikit-learn** - один из наиболее широко используемых пакетов Python для Data Science и Machine Learning. Он позволяет выполнять множество операций и предоставляет множество алгоритмов.
+
+**NumPy** — это фундаментальный пакет для научных вычислений на Python.
+
+**Pandas** — это библиотека с открытым исходным кодом, предоставляющая высокопроизводительные, простые в использовании структуры данных и инструменты анализа данных для языка программирования Python.
+
+**Operator** — предоставляет функции для встроенных операторов и функции для создания вызываемых объектов, которые извлекают элементы, атрибуты и методы вызова.
+***
+## *Что делает ЛР:*
+В данной работе анализируется работа нескольких моделей, способных оценить важность признаков 
+в регрессионной проблеме Фридмана. Генерируются исходные данные, в которых признаки x1-x5 
+являются влиятельными, а признаки x11-x14 зависимыми от других признаков. Далее три модели (по варианту) 
+ранжируют признаки по их значимости.
+
+**Результатом работы программы** являются: вывод оценок важности признаков по моделям и вывод средних оценок важности признаков (в консоли).
+***
+## *Пример выходных данных:*
+>Вывод в консоли:
+
+![](https://sun9-4.userapi.com/impg/mWP_l-9Hew6DDSzL-XDoVtLC6x9V3smayeyJGw/0w0t35B3Bm0.jpg?size=604x266&quality=96&sign=5e50ac631ba8bb78ad8796d1e030a579&type=album)
+![](https://sun9-74.userapi.com/impg/CgXruyB6e9nbe3LHxemcSRquslcD-M6YMzWmRA/WJ5QF0yTkBg.jpg?size=801x329&quality=96&sign=b11fa4cc83bf7a82ec6d280994193488&type=album)
+***
+**Вывод**: 
+*Модель Лассо* отобрала признаки x1-x5 (кроме x3) как значимые параметры, а оценки всех остальных признаков приравняла к нулю. Ранжирование получилось весьма точным (включился бы x3 - было бы совсем точно), а зависимые признаки не были отмечены важными ни в какой степени.
+
+*Модель Рекурсивного сокращения признаков* сработала лучше Лассо: влиятельные признаки (x1-x5) и 2 из 4 зависимых признаков (x11 и x13) - обозначила точно значимыми. Оставшиеся зависимые признаки (x12 и x14) оценила чуть менее, но важными. 
+
+*Модель Линейной корреляции* из значимых (x1-x5) выделила важным только x4, признаки x1 и x2 слабо важными, а x5 и x3 незначимыми. Среди зависимых признаков (x11-x14) важным оказался x14.
+
+Cамыми важными признаками по среднему значению оказались: x4, x2, x1, x5.

martysheva_tamara_lab_2/lab2.py

@@ -0,0 +1,71 @@
+from sklearn.linear_model import Lasso, LinearRegression
+from sklearn.feature_selection import RFE, f_regression
+from sklearn.preprocessing import MinMaxScaler
+import numpy as np
+import pandas as pd
+from operator import itemgetter
+
+#Генерируем исходные данные
+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))
+
+#Создаем и тренируем модели
+lasso = Lasso(alpha=.05)
+lasso.fit(X, Y)
+#
+lr = LinearRegression()
+lr.fit(X, Y)
+rfe = RFE(lr)
+rfe.fit(X, Y)
+#
+f, pval = f_regression(X, Y, center=True)
+
+# Функция для преобразования оценок признаков в словарь
+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))
+
+# Функция нахождения средних оценок по признакам
+def average_ranks(ranks):
+    avg_ranks = {}
+    for key, value in ranks.items():
+        for item in value.items():
+            if (item[0] not in avg_ranks):
+                avg_ranks[item[0]] = 0
+                avg_ranks[item[0]] += item[1]
+
+    for key, value in avg_ranks.items():
+        res = value / len(ranks)
+        avg_ranks[key] = round(res, 2)
+    avg_ranks = sorted(avg_ranks.items(), key=itemgetter(1), reverse=True)
+    return avg_ranks
+
+#Создаем список с именами признаков
+names = ["x%s" % i for i in range(1, 15)]
+ranks = dict()
+#Применяем функцию к моделям
+ranks["Lasso"] = rank_to_dict(lasso.coef_, names)
+ranks["RFE"] = rank_to_dict(rfe.ranking_, names)
+ranks["F_reg"] = rank_to_dict(f, names)
+#Т.к. в RFE ранг "1" = признак важный, а если больше "1" - то менее важный
+#поменяем оценки на противоположные
+record_key = 'RFE'
+for key, value in ranks[record_key].items():
+    ranks[record_key][key] = 1 - value
+
+# Вывод оценок каждого признака
+table_ranks = pd.DataFrame.from_dict(ranks, orient='columns')
+print("Оценки важности признаков по моделям: Лассо, Рекурсивное сокращение признаков, Линейная корреляция:")
+print(table_ranks)
+# Вывод средних оценок каждого признака
+table_avg_ranks = pd.DataFrame.from_records(average_ranks(ranks))
+print("Средние оценки важности признаков")
+print(table_avg_ranks.to_string(index=False, header=False))

romanova_adelina_lab_1/README.md

@@ -0,0 +1,69 @@
+
+# Лабораторная №1. Вариант №21
+
+## Тема: 
+Работа с типовыми наборами данных и различными моделями
+## Задание:
+
+Сгенерировать определённый тип данных, сравнить на нём разные модели и отобразить качество на графиках.
+
+Данные: make_classification (n_samples=500, n_features=2, n_redundant=0, n_informative=2, random_state=rs, n_clusters_per_class=1) 
+
+Модели: 
+- Линейная регрессия 
+- Полиномиальная регрессия (со степенью 5)
+- Гребневая полиномиальная регрессия (со степенью 5, alpha = 1.0)
+
+## Как запустить программу?
+Необходимо запустить файл **main.py**
+## Использованные технологии
+
+Этот код использует несколько библиотек и технологий для создания синтетических данных, обучения различных моделей регрессии и визуализации результатов. Вот краткое описание использованных технологий:
+
+1. **NumPy** - это библиотека для работы с массивами и матрицами чисел. Она используется для создания и манипуляции данными.
+
+1. **Matplotlib** - это библиотека для создания графиков и визуализации данных. Она используется для отображения данных на графиках.
+
+1. **Scikit-learn** - это библиотека машинного обучения, которая предоставляет множество инструментов для обучения моделей и анализа данных. В этом коде используются следующие модули из этой библиотеки:
+
+- *make_classification* - используется для генерации синтетических данных классификации.
+- *train_test_split* - используется для разделения данных на обучающий и тестовый наборы.
+- *linearRegression* - используется для создания и обучения линейной регрессии.
+- *polynomialFeatures* - используется для создания полиномиальных признаков.
+- *ridge* - используется для создания и обучения гребневой полиномиальной регрессии.
+- *r2_score* - используется для вычисления коэффициента детерминации модели.
+
+## Описание работы
+
+Сначала программа использует функцию **make_classification** для создания синтетических данных. Эти данные представляют собой два признака и являются результатом задачи классификации. Всего создается 500 точек данных.
+
+Сгенерированные данные разделяются на обучающий и тестовый наборы с использованием функции **train_test_split**. Обучающий набор содержит 80% данных, а тестовый набор - 20%. 
+
+Далее прооисходит обучение моделей. Для каждой строятся графики, на которых отображаются тестовые данные и предсказанные значения для оценки, насколько хорошо модель соответствует данным.
+
+Для каждой модели программа вычисляет коэффициент детерминации с использованием функции **r2_score**.
+
+Программа создает, обучает и визуализирует три модели регрессии и позволяет оценить их производительность на сгенерированных данных.
+
+## Выходные данные
+Была выведена следующая точность у моделей:
+```
+Линейная регрессия с точностью 0.52 
+Полиномиальная регрессия с точностью -0.20 
+Гребневая полиномиальная регрессия с точностью -0.09
+```
+Графики результатов построены следующим образом:
+- Линейная регрессия
+
+![](1.png "")
+
+- Полиномиальная регрессия
+
+![](2.png "")
+
+- Гребневая полиномиальная регрессия
+
+![](3.png "")
+
+Линейная регрессия показала наилучшую точность с точностью, равной 0.52, что указывает на приемлемую предсказательную способность модели. Полиномиальная и гребневая полиномиальная регрессии со значениями -0.20 и -0.09 соответственно, демонстрируют низкую точность. 
+

romanova_adelina_lab_1/main.py

@@ -0,0 +1,79 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression, Ridge
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.metrics import mean_squared_error, r2_score
+
+# Данные:
+# make_classification (
+# n_samples=500           - Общее количество точек данных
+# n_features=2,           - Количество признаков
+# n_redundant=0,          - Количество избыточных признаков
+# n_informative=2         - Количество информативных признаков
+# random_state=rs         - Задаем случайное состояние для воспроизводимости
+# n_clusters_per_class=1  - Количество кластеров для каждого класса)
+
+# Используемые модели:
+# 1. Линейная регрессию
+# 2. Полиномиальная регрессия (со степенью 5)
+# 3. Гребневая полиномиальная регрессия (со степенью 5, alpha = 1.0)
+
+# Генерация данных
+X, y = make_classification(n_samples=500, n_features=2, n_redundant=0, n_informative=2, random_state=42, n_clusters_per_class=1)
+
+# Разделение данных на обучающий и тестовый наборы
+
+# train_test_split - функция разделения данных на обучающий и тестовый наборы
+# test_size - доля данных, которая будет использоваться для тестирования модели (20% для тестирования)
+# random_state - установка начального состояния генератора случайных чисел
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Обучение моделей
+
+# Линейная регрессия
+lr = LinearRegression()
+lr.fit(X_train, y_train)
+y_lr_pred = lr.predict(X_test)
+r2_lr = r2_score(y_test, y_lr_pred)
+
+# Полиномиальная регрессия
+poly = PolynomialFeatures(degree=5)
+X_train_poly = poly.fit_transform(X_train)
+X_test_poly = poly.transform(X_test)
+lr_poly = LinearRegression()
+lr_poly.fit(X_train_poly, y_train)
+y_poly_pred = lr_poly.predict(X_test_poly)
+r2_poly = r2_score(y_test, y_poly_pred)
+
+# Гребневая полиномиальная регрессия
+ridge = Ridge(alpha=1.0)
+ridge.fit(X_train_poly, y_train)
+y_ridge_pred = ridge.predict(X_test_poly)
+r2_ridge = r2_score(y_test, y_ridge_pred)
+
+# Графики
+
+# Функция для отображения точек на графике
+def plot_with_labels(X, y, title, xlabel, ylabel):
+    plt.figure(figsize=(12, 6))
+    plt.scatter(X[:, 0], X[:, 1], c=y, cmap='viridis', marker='.', label='Тестовые данные')
+    plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap='viridis', marker='o', edgecolors='black', linewidths=0.5, label='Обучающие данные')
+    plt.title(title)
+    plt.xlabel(xlabel)
+    plt.ylabel(ylabel)
+    plt.legend()
+    plt.show()
+
+# График для линейной регрессии
+plot_with_labels(X_test, y_lr_pred, 'Линейная регрессия', 'Признак 1', 'Признак 2')
+print(f'Линейная регрессия - Точность: {r2_lr:.2f}')
+
+# График для полиномиальной регрессии
+plot_with_labels(X_test, y_poly_pred, 'Полиномиальная регрессия', 'Признак 1', 'Признак 2')
+print(f'Полиномиальная регрессия - Точность: {r2_poly:.2f}')
+
+# График для гребневой полиномиальной регрессии
+plot_with_labels(X_test, y_ridge_pred, 'Гребневая полиномиальная регрессия', 'Признак 1', 'Признак 2')
+print(f'Гребневая полиномиальная регрессия - Точность: {r2_ridge:.2f}')

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>