arutunyan_dmitry_lab_1 is ready

2023-10-07 19:28:43 +04:00 · 2023-10-07 19:28:43 +04:00 · bbb46d3cd1
commit bbb46d3cd1
parent 06116369e5
45 changed files with 182 additions and 826 deletions
--- a/.idea/.gitignore
+++ b/.idea/.gitignore
@ -1,3 +0,0 @@
 # Default ignored files
 /shelf/
 /workspace.xml
--- a/.idea/IIS_2023_1.iml
+++ b/.idea/IIS_2023_1.iml
@ -1,8 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="PYTHON_MODULE" version="4">
  <component name="NewModuleRootManager">
    <content url="file://$MODULE_DIR$" />
    <orderEntry type="jdk" jdkName="Python 3.8 (venv)" jdkType="Python SDK" />
    <orderEntry type="sourceFolder" forTests="false" />
  </component>
 </module>
--- a/.idea/inspectionProfiles/profiles_settings.xml
+++ b/.idea/inspectionProfiles/profiles_settings.xml
@ -1,6 +0,0 @@
 <component name="InspectionProjectProfileManager">
  <settings>
    <option name="USE_PROJECT_PROFILE" value="false" />
    <version value="1.0" />
  </settings>
 </component>
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@ -1,4 +0,0 @@
 <?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" />
 </project>
--- a/.idea/modules.xml
+++ b/.idea/modules.xml
@ -1,8 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="ProjectModuleManager">
    <modules>
      <module fileurl="file://$PROJECT_DIR$/.idea/IIS_2023_1.iml" filepath="$PROJECT_DIR$/.idea/IIS_2023_1.iml" />
    </modules>
  </component>
 </project>
--- a/.idea/vcs.xml
+++ b/.idea/vcs.xml
@ -1,6 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="VcsDirectoryMappings">
    <mapping directory="$PROJECT_DIR$" vcs="Git" />
  </component>
 </project>
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@ -1,92 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="ChangeListManager">
    <list default="true" id="0ceb130e-88da-4a20-aad6-17f5ab4226ac" name="Changes" comment="">
      <change afterPath="$PROJECT_DIR$/zavrazhnova_svetlana_lab_2/result.png" afterDir="false" />
    </list>
    <option name="SHOW_DIALOG" value="false" />
    <option name="HIGHLIGHT_CONFLICTS" value="true" />
    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
    <option name="LAST_RESOLUTION" value="IGNORE" />
  </component>
  <component name="FileTemplateManagerImpl">
    <option name="RECENT_TEMPLATES">
      <list>
        <option value="Python Script" />
      </list>
    </option>
  </component>
  <component name="Git.Settings">
    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
  </component>
  <component name="MarkdownSettingsMigration">
    <option name="stateVersion" value="1" />
  </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/IISLabs/IIS_2023_1"
  }
 }]]></component>
  <component name="RecentsManager">
    <key name="CopyFile.RECENT_KEYS">
      <recent name="D:\ulstukek\Course4\IIS\IISLabs\IIS_2023_1\zavrazhnova_svetlana_lab_1" />
    </key>
  </component>
  <component name="RunManager">
    <configuration name="zavrazhnova_svetlana_lab_2" type="PythonConfigurationType" factoryName="Python" temporary="true" nameIsGenerated="true">
      <module name="IIS_2023_1" />
      <option name="INTERPRETER_OPTIONS" value="" />
      <option name="PARENT_ENVS" value="true" />
      <envs>
        <env name="PYTHONUNBUFFERED" value="1" />
      </envs>
      <option name="SDK_HOME" value="" />
      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/zavrazhnova_svetlana_lab_2" />
      <option name="IS_MODULE_SDK" value="true" />
      <option name="ADD_CONTENT_ROOTS" value="true" />
      <option name="ADD_SOURCE_ROOTS" value="true" />
      <option name="SCRIPT_NAME" value="$PROJECT_DIR$/zavrazhnova_svetlana_lab_2/zavrazhnova_svetlana_lab_2.py" />
      <option name="PARAMETERS" value="" />
      <option name="SHOW_COMMAND_LINE" value="false" />
      <option name="EMULATE_TERMINAL" value="false" />
      <option name="MODULE_MODE" value="false" />
      <option name="REDIRECT_INPUT" value="false" />
      <option name="INPUT_FILE" value="" />
      <method v="2" />
    </configuration>
    <recent_temporary>
      <list>
        <item itemvalue="Python.zavrazhnova_svetlana_lab_2" />
      </list>
    </recent_temporary>
  </component>
  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
  <component name="TaskManager">
    <task active="true" id="Default" summary="Default task">
      <changelist id="0ceb130e-88da-4a20-aad6-17f5ab4226ac" name="Changes" comment="" />
      <created>1695412818437</created>
      <option name="number" value="Default" />
      <option name="presentableId" value="Default" />
      <updated>1695412818437</updated>
    </task>
    <servers />
  </component>
  <component name="Vcs.Log.Tabs.Properties">
    <option name="TAB_STATES">
      <map>
        <entry key="MAIN">
          <value>
            <State />
          </value>
        </entry>
      </map>
    </option>
  </component>
 </project>
--- a/README.md
+++ b/README.md
@ -1,70 +0,0 @@
 # IIS_2023_1
 ПРАВИЛА ИГРЫ при сдаче лабораторных работ по предмету "Интеллектуальные информационные системы".
 Всем Доброго времени суток! Настоятельно прошу прочитать этот файл от начала и до конца. 
 **Задание на л/р**
 0. Требования к языку программирования: python.
 Для выполнения лабораторных работ можно использовать любую IDE или текстовый редактор.
 1. Файл с заданиями находится в корне проекта ([MetodichkaMII_MO.pdf](http://student.git.athene.tech/Alexey/IIS_2023_1/src/branch/main/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4%D0%B8%D1%87%D0%BA%D0%B0%D0%9C%D0%98%D0%98_%D0%9C%D0%9E-1.pdf)). 
 2. Наши л/р показаны на [скриншоте](http://student.git.athene.tech/Alexey/IIS_2023_1/src/branch/main/labs.jpg). Или все 7 л/р по курсу "Машинное обучение".
 Обратите внимание, что лабораторные работы 3-7 выполняются на варианте данных вашей курсовой работы (Массивы данныхдля лабораторныхработ).
 **Воркфлоу по сдаче лабораторных работ**
 0. Клонируем себе репозиторий на компьютер
 > git clone http://student.git.athene.tech/Alexey/IIS_2023_1.git
 1. Для выполнения очередной лабораторной работы необходимо завести отдельную ветку (перед этим необходимо выполнить команду git checkout master). Указанный формат наименования ветки <фамилия_имя_lab_номер_лабораторной> ОБЯЗАТЕЛЕН, в противном случае лабораторная работа не проверяется!
 > git checkout -b "zhelepov_alex_lab_1"
 При этом Вы окажетесь в своей ветке, в которой Вам и предстоит выполнять лабораторную работу.
 2. В ветке создаём папку в аналогичном формате <фамилия_имя_lab_номер_лабораторной>, формат также ОБЯЗАТЕЛЕН, в противном случае лабораторная работа не проверяется!
 > mkdir zhelepov_alex_lab_1
 3. Весь код лабораторной работы и отчет должны находится внутри этой папки! То есть файловая структура репозитория должна иметь такой вид
 > ivanov_ivan_lab_1 zhelepov_alex_lab_1 README.md
 4. Отчет к лабораторной работе должен быть оформлен в виде файла readme.md, в котором Вы сможете дать краткое описание того, что делает Ваша программа. Очень хорошо (большой плюс при сдаче), если Вы опишите следующие пункты:
 * как запустить лабораторную работу
 * какие технологии использовали
 * что она делает
 * тесты, то есть несколько примеров входных и выходных значений
 Небольшой [гайд](https://guides.github.com/features/mastering-markdown/) по синтаксису для оформления отчёта.
 P.S. я знаю про хак "хочу скопировать у товарища этот волшебный readme и ничего не делать", но пожалуйста не делайте так (я буду обязательно проверять это) 
 4. Как только Вы закончили работу над лабораторной работой, то находясь в своей ветке (убедитесь в этом пожалуйста, использую команду git branch - ваша текущая ветка будет подсвечена), вы должны закоммитить и запушить свои изменения в репозиторий, другими словами сохранить их в репозиторий.
 > git commit -m "zhelepov_alex_lab_1 is ready"
 > git push origin
 P.S. я знаю про хак "скопируй у товарища и закоммить - все равно он (я) смотреть не будет" - не сработает - давайте быть честными и делать все самостоятельно. А во-вторых, на реальной работе так не прокатит - скорее всего Вас просто уволят.
 5. После этого Вы должны перейти в наш git и создать merge request, назначив его на меня. Дополнительно лучше маякнуть меня в нашем [телеграм-чате](https://t.me/+XSq2xEbEuD05N2Vi). Я проведу ревью и отпишу замечания, которые нужно будет исправить. Если все хорошо, то вмержу ваш pull-request в мастер-ветку. Данное состояние говорит о том, что ваша л/р принята.
 6. **Важный момент**: Устно я не принимаю лабораторные работы (подойти к компьютеру, посмотреть код, поставить оценку), только через репозиторий и после успешного code review ревью кода вашей л/р и ее результатов в виде отчета. Это делается для того, чтобы вы привыкали к воркфлоу, который применяется практически всеми IT-компаниями, где между разработчиками в основном общение идет через "текст". Что касается лабораторных работ в расписании - они используются в качестве консультаций, а сдача и проверка л/р идет только через репозиторий (то есть все замечания вы получаете на code review). Проверяю я обычно лабораторную в течение 1-3 дней после создания pull-request-а (всегда можно маякнуть меня в нашем telegram-чате).
 **Чек-лист для старост групп**
 0. Убедиться, что все из списка зашли в [телеграм-чат](https://t.me/+XSq2xEbEuD05N2Vi), где мы будем общаться + я буду публиковать различные объявления. ПОЖАЛУЙСТА, ОБРАТИТЕ НА ЭТО ВНИМАНИЕ и доведите до всех! В других каналах связя меня сложно выцепить или я могу пропустить сообщение.
 1. Убедиться, что все зарегистрировались на университетском [git](http://student.git.athene.tech/) и добавились для работы с нашим репозиторием. А добавляться в этот [репозиторий](http://student.git.athene.tech/Alexey/IIS_2023_1).
 **Полезные ссылки:**
 0. Отличный тьюториал по гиту (рекомендую всем его пройти), вот [тут](https://learngitbranching.js.org/)
 1. Гайд по markdown [тут](https://guides.github.com/features/mastering-markdown/)
 БОЛЬШОЕ СПАСИБО, что дочитали этот README до конца! И Удачи Вам в сдаче л/р и не только!
--- a/alexandrov_dmitrii_lab_1/lab1.py
+++ b/alexandrov_dmitrii_lab_1/lab1.py
@ -1,56 +0,0 @@
 import random
 from matplotlib import pyplot as plt
 from matplotlib.colors import ListedColormap
 from sklearn.datasets import make_moons
 from sklearn.linear_model import LinearRegression, Ridge
 from sklearn.model_selection import train_test_split
 from sklearn.preprocessing import PolynomialFeatures
 from sklearn.pipeline import Pipeline
 rs = random.randrange(50)
 X, y = make_moons(n_samples=250, 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=42)
 figure = plt.figure(1, figsize=(16, 9))
 axis = figure.subplots(4, 3)
 cm = ListedColormap(['#FF0000', "#0000FF"])
 arr_res = list(range(len(y_test)))
 X_scale = list(range(len(y_test)))
 def test(col, model):
    global axis
    global arr_res
    global X_test
    global X_train
    global y_train
    global y_test
    model.fit(X_train, y_train)
    res_y = model.predict(X_test)
    print(model.score(X_test, y_test))
    axis[0, col].scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm)
    axis[1, col].scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm)
    axis[2, col].scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm)
    axis[2, col].scatter(X_test[:, 0], X_test[:, 1], c=res_y, cmap=cm)
    axis[3, col].plot([i for i in range(len(res_y))], y_test, c="g")
    axis[3, col].plot([i for i in range(len(res_y))], res_y, c="r")
 def start():
    lin = LinearRegression()
    poly = Pipeline([('poly', PolynomialFeatures(degree=3)),
                     ('linear', LinearRegression())])
    ridge = Pipeline([('poly', PolynomialFeatures(degree=3)),
                      ('ridge', Ridge(alpha=1.0))])
    test(0, lin)
    test(1, poly)
    test(2, ridge)
    plt.show()
 start()
--- a/alexandrov_dmitrii_lab_1/readme.md
+++ b/alexandrov_dmitrii_lab_1/readme.md
@ -1,46 +0,0 @@
 ## Задание
 Сгенерировать определенный тип данных и сравнить на нем 3 модели. Построить графики, отобразить качество моделей, объяснить полученные результаты.
 Вариант 1.
 Данные: make_moons (noise=0.3, random_state=rs)
 Модели:
 · Линейная регрессия
 · Полиномиальная регрессия (со степенью 3)
 · Гребневая полиномиальная регрессия (со степенью 3, alpha = 1.0) 
 ### Запуск программы
 Файл lab1.py содержит и запускает программу, аргументов и настройки ~~вроде~~ не требует, 
 ### Описание программы
 Генерирует один из 50 наборов данных, показывает окно с графиками и пишет оценку моделей обучения по заданию. 
 Использует библиотеки matplotlib для демонстрации графиков и sklearn для создания и использования моделей. 
 ### Результаты тестирования
 Для различных значений rs результаты следующие:
 значение - линейная - полиномиальная - гребневая полиномиальная
 1 - 0.54 - 0.08 - 0.35
 2 - 0.62 - 0.58 - 0.63
 3 - 0.6 - 0.67 - 0.65
 4 - 0.52 - 0.46 - 0.5
 5 - 0.4 - 0.42 - 0.44
 Из данных результатов можно заключить, что чёткой зависимости точности от выбранной модели нет.
 Однако, после этого я добавил в генератор данных число значений: 500. Результаты оказались более детерминированными:
 значение - линейная - полиномиальная - гребневая полиномиальная
 1 - 0.54 - 0.63 - 0.63
 2 - 0.52 - 0.63 - 0.62
 3 - 0.56 - 0.64 - 0.64
 4 - 0.5 - 0.63 - 0.62
 5 - 0.5 - 0.52 - 0.53
 Из данных результатов можно заключить, что в общем случае модель линейной регрессии уступает полиномиальным. Гребневая полиномиальная регрессия чаще уступала обычной полиномиальной, однако в незначительном количестве ситуаций была оценена выше - но во всех случаях результаты были близки, поэтому можно с уверенностью предположить, что результаты идентичны и различаются по воле шума обучения.
 После изучения число значений в генераторе заменено на 250, поскольку графики становились неразличимыми^
 значение - линейная - полиномиальная - гребневая полиномиальная
 1 - 0.48 - 0.54 - 0.54
 2 - 0.5 - 0.56 - 0.56
 3 - 0.57 - 0.6 - 0.6
 4 - 0.57 - 0.66 - 0.68
 5 - 0.49 - 0.54 - 0.55
 По данным результатам видно, что в большинстве ситуаций уже гребневая полиномиальная регрессия показывает лучшую точность.
 Результаты объясняются следующим образом: 
 Линейная регрессия будучи математически прямой плохо отражает сложные функции и нелинейные зависимости, в то время как полиномиальная регрессия способна отражать перегибы и изменяющиеся в зависимости от меры значений зависимости. Гребневая полиномиальная вышла идентичной простой полиномиальной из-за одинаковых настроек - обе они по заданию имеют третью степень, а гребневая регрессия имеет слишком малый параметр alpha, что результирует в малом эффекте гребневой функции.
--- a/antonov_dmitry_lab_1/README.md
+++ b/antonov_dmitry_lab_1/README.md
@ -1,97 +0,0 @@
 # Лаб 1
 Работа с типовыми наборами данных и различными моделями
 # Вариант 3
 Данные: make_classification (n_samples=500, n_features=2,
 n_redundant=0, n_informative=2, random_state=rs, n_clusters_per_class=1)
 # Запуск
 Выполнением скрипта файла (вывод в консоль + рисует графики).
 # Модели:
 1. Линейная регрессия
 1. Полиномиальная регрессия (со степенью 3)
 1. Гребневая полиномиальная регрессия (со степенью 3, alpha = 1.0)
 # Графики
 <div>
 Качество каждой модели может быть оценено на основе среднеквадратичной ошибки (MSE). 
 Более низкая MSE указывает на лучшее соответствие данным. 
 Однако выбор модели зависит от набора данных и лежащей в основе взаимосвязи между объектами и целевой переменной.
 Линейная регрессия: Линейная регрессия предполагает линейную зависимость между признаками и целевой переменной.
 Это хорошо работает, когда взаимосвязь линейна, а шум в наборе данных минимален.
 Лучше всего сработала на наборе лун. Хуже всего на кругах.
 На линейном наборе показала себя на равне с остальными.
 Полиномиальная и гребневая показали примерно одинаково на всех наборах.
 Полиномиальная регрессия (степень=3):
 Полиномиальная регрессия обеспечивает более гибкую подгонку за счет полинома более высокого порядка(кубическая кривая).
 Она может выявить более сложные взаимосвязи между объектами и целевой переменной.
 Она может сработать лучше, чем линейная регрессия, если истинная взаимосвязь нелинейна.
 Гребневая регрессия (степень= 3, альфа=1,0):
 В случае полиномиальной регрессии с регуляризацией (альфа=1,0) модель добавляет коэффициент регуляризации
 для управления сложностью обучения. Регуляризация помогает предотвратить переобучение, когда набор
 данных содержит шум или когда он ограничен.
 </div>
 <p>
    <div>Набор лун (moon_dataset)</div>
    <img src="screens/myplot1.png" width="650" title="датасет 1">
 </p>
 <p>
    <div>Графики регрессии</div>
    <img src="screens/myplot2.png" width="450" title="линейная модель">
    <img src="screens/myplot3.png" width="450" title="полиномиальная модель">
    <img src="screens/myplot4.png" width="450" title="гребневая модель">
    <div>
        Линейная MSE: 0.0936
        Полиномиальная (degree=3) MSE: 0.0674
        Гребневая (degree=3, alpha=1.0) MSE: 0.0682
    </div>
 </p>
 <p>
    <div>Набор кругов (circles_dataset)</div>
    <img src="screens/myplot5.png" width="650" title="датасет 2">
 </p>
 <p>
  <div>Графики регрессии</div>
    <img src="screens/myplot6.png" width="450" title="линейная модель">
    <img src="screens/myplot7.png" width="450" title="полиномиальная модель">
    <img src="screens/myplot8.png" width="450" title="гребневая модель">
    <div>
        Линейная MSE: 0.2684
        Полиномиальная (degree=3) MSE: 0.1341
        Гребневая (degree=3, alpha=1.0) MSE: 0.1312
    </div>
 </p>
 <p>
    <div>Набор линейный (linearly_dataset)</div>
    <img src="screens/myplot9.png" width="650" title="датасет 3">
 </p>
 <p>
    <div>Графики регрессии</div>
    <img src="screens/myplot10.png" width="450" title="линейная модель">
    <img src="screens/myplot11.png" width="450" title="полиномиальная модель">
    <img src="screens/myplot12.png" width="450" title="гребневая модель">
    <div>
        Линейная MSE: 0.1101
        Полиномиальная (degree=3) MSE: 0.1045
        Гребневая (degree=3, alpha=1.0) MSE: 0.1078
    </div>
 </p>
 <div>
 Итоговая модель подбирается учитывая зависимость в данных,
 как правило полиномиальная регрессия справляется лучше, а коэф регуляризации в гребневой регрессии помогает избежать
 переобучения.
 </div>
--- a/antonov_dmitry_lab_1/lab1.py
+++ b/antonov_dmitry_lab_1/lab1.py
@ -1,97 +0,0 @@
 import numpy as np
 from matplotlib import pyplot as plt
 from skimage.metrics import mean_squared_error
 from sklearn.datasets import make_moons, make_circles, make_classification
 from sklearn.linear_model import LinearRegression, Ridge
 from sklearn.model_selection import train_test_split
 from sklearn.pipeline import make_pipeline
 from sklearn.preprocessing import StandardScaler, PolynomialFeatures
 X, y = make_classification(
    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)
 linearly_dataset = (X, y)
 moon_dataset = make_moons(noise=0.3, random_state=0)
 circles_dataset = make_circles(noise=0.2, factor=0.5, random_state=1)
 datasets = [moon_dataset, circles_dataset, linearly_dataset]
 """
 Данные:
 · moon_dataset
 · circles_dataset
 · linearly_dataset
 """
 for ds_cnt, ds in enumerate(datasets):
    X, y = ds
    X = StandardScaler().fit_transform(X)
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=.4, random_state=42
    )
    """
    Модели:
    · Линейную регрессию
    · Полиномиальную регрессию (со степенью 3)
    · Гребневую полиномиальную регрессию (со степенью 3, alpha = 1.0)
    """
    # Линейная
    linear_regression = LinearRegression()
    linear_regression.fit(X_train, y_train)
    linear_predictions = linear_regression.predict(X_test)
    linear_mse = mean_squared_error(y_test, linear_predictions)
    # Полиномиальная (degree=3)
    poly_regression = make_pipeline(PolynomialFeatures(degree=3), LinearRegression())
    poly_regression.fit(X_train, y_train)
    poly_predictions = poly_regression.predict(X_test)
    poly_mse = mean_squared_error(y_test, poly_predictions)
    # Гребневая (degree=3, alpha=1.0)
    poly_regression_alpha = make_pipeline(PolynomialFeatures(degree=3), Ridge(alpha=1.0))
    poly_regression_alpha.fit(X_train, y_train)
    poly_alpha_predictions = poly_regression_alpha.predict(X_test)
    poly_alpha_mse = mean_squared_error(y_test, poly_alpha_predictions)
    # График данных
    plt.figure(figsize=(10, 6))
    plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap='coolwarm')
    plt.title('Датасет №' + str(ds_cnt))
    plt.xlabel('X')
    plt.ylabel('Y')
    # График линейной модели
    plt.figure(figsize=(10, 6))
    plt.scatter(X_test[:, 0], X_test[:, 1], c=linear_predictions, cmap='coolwarm')
    plt.title('Линейная ds'+ str(ds_cnt))
    plt.xlabel('X')
    plt.ylabel('Y')
    plt.show()
    # График полиномиальной модели (degree=3)
    plt.figure(figsize=(10, 6))
    plt.scatter(X_test[:, 0], X_test[:, 1], c=poly_predictions, cmap='coolwarm')
    plt.title('Полиномиальная (degree=3) ds' + str(ds_cnt))
    plt.xlabel('X')
    plt.ylabel('Y')
    plt.show()
    # График гребневой модели (degree=3, alpha=1.0)
    plt.figure(figsize=(10, 6))
    plt.scatter(X_test[:, 0], X_test[:, 1], c=poly_alpha_predictions, cmap='coolwarm')
    plt.title('Гребневая (degree=3, alpha=1.0) ds' + str(ds_cnt))
    plt.xlabel('X')
    plt.ylabel('Y')
    plt.show()
    # Сравнение качества
    print('Линейная MSE:', linear_mse)
    print('Полиномиальная (degree=3) MSE:', poly_mse)
    print('Гребневая (degree=3, alpha=1.0) MSE:', poly_alpha_mse)
--- a/antonov_dmitry_lab_1/screens/myplot1.png
+++ b/antonov_dmitry_lab_1/screens/myplot1.png
--- a/antonov_dmitry_lab_1/screens/myplot10.png
+++ b/antonov_dmitry_lab_1/screens/myplot10.png
--- a/antonov_dmitry_lab_1/screens/myplot11.png
+++ b/antonov_dmitry_lab_1/screens/myplot11.png
--- a/antonov_dmitry_lab_1/screens/myplot12.png
+++ b/antonov_dmitry_lab_1/screens/myplot12.png
--- a/antonov_dmitry_lab_1/screens/myplot2.png
+++ b/antonov_dmitry_lab_1/screens/myplot2.png
--- a/antonov_dmitry_lab_1/screens/myplot3.png
+++ b/antonov_dmitry_lab_1/screens/myplot3.png
--- a/antonov_dmitry_lab_1/screens/myplot4.png
+++ b/antonov_dmitry_lab_1/screens/myplot4.png
--- a/antonov_dmitry_lab_1/screens/myplot5.png
+++ b/antonov_dmitry_lab_1/screens/myplot5.png
--- a/antonov_dmitry_lab_1/screens/myplot6.png
+++ b/antonov_dmitry_lab_1/screens/myplot6.png
--- a/antonov_dmitry_lab_1/screens/myplot7.png
+++ b/antonov_dmitry_lab_1/screens/myplot7.png
--- a/antonov_dmitry_lab_1/screens/myplot8.png
+++ b/antonov_dmitry_lab_1/screens/myplot8.png
--- a/antonov_dmitry_lab_1/screens/myplot9.png
+++ b/antonov_dmitry_lab_1/screens/myplot9.png
--- a/arutunyan_dmitry_lab_1/1.png
+++ b/arutunyan_dmitry_lab_1/1.png
--- a/arutunyan_dmitry_lab_1/2.png
+++ b/arutunyan_dmitry_lab_1/2.png
--- a/arutunyan_dmitry_lab_1/3.png
+++ b/arutunyan_dmitry_lab_1/3.png
--- a/arutunyan_dmitry_lab_1/README.md
+++ b/arutunyan_dmitry_lab_1/README.md
@ -0,0 +1,93 @@
 ## Лабораторная работа 1. Вариант 4.
 ### Задание 
 Построить графики, отобразить 
 качество моделей, объяснить полученные результаты.
 Данные: `make_moons (noise=0.3, random_state=rs)`
 Модели:
 - Линейная регресся 
 - Полиномиальная регрессия (со степенью 4) 
 - Гребневая полиномиальная регресся (со степенью 4, alpha = 1.0)
 ### Как запустить
 Для запуска программы необходимо с помощью командной строки в корневой директории файлов прокета прописать:
 ```
 python main.py
 ```
 После этого в папке static сгенерируются 4 графика, по которым оценивается результат выполнения программы.
 ### Используемые технологии
 - Библиотека `pyplot`, используемая для построения графиков. 
 - Библиотека `sklearn` - большой набор функционала для анализа данных. Из неё были использованы инструменты:
    - `make_moons` -  генератор случайных структурированных данных
    - `train_test_split` - разделитель данных на обучающиую и тестовую выборки
    - `LinearRegression` - инструмент работы с моделью "Линейная регрессия"
    - `Ridge` - инструмент работы с моделью "Гребневая регрессия"
    - `PolynomialFeatures` - инструмент работы с моделью "Полиномиальная регрессия"
    - `metrics` - набор инструменов для оценки моделей
 - Библиотека `numpy`, используемая для обработки массивов данных и вычислений
 ### Описание работы
 Программа генерирует данные для обучения и тестирования моделей, стандартизирует данные и разделяет их на обучающую и тестовую выборки.
 ```python
 X, y = make_moons(noise=0.3, random_state=None)                                                 
 X = StandardScaler().fit_transform(X)                                                            
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4, random_state=42)
 ```
 После чего, на данных `X_train` и `y_train` производится обучение моделей, а на данных `X_test` и `y_test` - оценка их качества.
 Поскольку все модели в задании регрессионные, результаты работы будем оценивать через решение задачи предсказания. Это позволит нам использовать для оценки только `y` данные, что облегчит построение графиков.
 Оценка качества моделей будет производиться по двум критериям - среднеквадратическому отклонению `mid_square` от истинного результата и коэфициенту детерминации `det_kp`. Чем среднеквадратическая ошибка меньше и чем коэфициент детерминации больше, тем лучше модель показала себя на данной выборке.
 ```python
 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)
 ```
 Где `y_predict` - решение задачи предсказания. Для наглядности, оценочные параметры округлим с помощью функции `round` до 3х и 2х знаков после запятой.
 #### Линейная регрессия
 Для создания модели линейной регрессии воспользуемся объектом `LinearRegression()`, обучим модель и заставим её предсказать значения `y` на тестовой выборке `x_text`.
 ```python
 linear = LinearRegression()         
 linear.fit(X_train, y_train)        
 y_predict = linear.predict(X_test)
 ```
 Построим график для оценки результатов:
 ![](1.png "")
 #### Полиномиальная регрессия
 Линейная регрессия является разновидностью полиномиальной регрессии со степенью ведущего члена равной 1. Чтобы построить модель полиномиальной регрессии со степенью 4 необходимо к данным модели линейной регрессии добавить 3 недостающих члена, возведённых в соответствующие степени 2, 3 и 4.
 ```python
 poly = PolynomialFeatures(degree=4, include_bias=False)
 x_poly_train = poly.fit_transform(X_train)
 x_poly_test = poly.fit_transform(X_test)
 ```
 Где `degree` - старшая степень полинома, `include_bias` - приведение свободного члена полинома к 0.
 Обучение и прогнозирование модели далее производится также, как с моделью линейной регрессии, но уде на данных `x_poly_train` и `x_poly_test`
 Построим график для оценки результатов:
 ![](2.png "")
 #### Полиномиальная гребневая регрессия
 Полиномиальная гребневая регрессия - это та же самая полиномиальная регрессия, но построенная с использованием усредняющего коэфициента. Для этого воспользуемся объёктом `Ridge()` и построим модель аналогично первым. 
 ```python
 ridge = Ridge(alpha=1.0)
 ridge.fit(x_poly_train, y_train)
 y_predict = ridge.predict(x_poly_test)
 ```
 Построим график для оценки результатов:
 ![](3.png "")
 Теперь построим график для сравнения работы всех моделей и выберем наилучшую:
 ![](result.png "")
 ### Вывод
 Наиболее низкое среднеквадратичное отклонение и наиболее высокий коэфициент детерминации показала модель линейной регрессии, а это значит что она наилучшем образом подходит для работы со сгенерированным данными. В этом случае мы можем предположить что данные выборки находятся на небольшом расстоянии друг от друга и располагаются линейно.
--- a/arutunyan_dmitry_lab_1/main.py
+++ b/arutunyan_dmitry_lab_1/main.py
@ -0,0 +1,89 @@
 import numpy as np
 from matplotlib import pyplot as plt
 from sklearn import metrics
 from sklearn.model_selection import train_test_split
 from sklearn.linear_model import LinearRegression, Ridge
 from sklearn.preprocessing import StandardScaler, PolynomialFeatures
 from sklearn.datasets import make_moons
 X, y = make_moons(noise=0.3, random_state=None)                                                  # Генерация данных с пересечениями признаков
 X = StandardScaler().fit_transform(X)                                                            # Стандартизация. Удаление средних, увеличение дисперсии до 1
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4, random_state=42)  # Разделение данных на обучающую и тестовую выборки
 # Модель линейной регрессии
 def lr_prediction():
    linear = LinearRegression()         # Создание модели
    linear.fit(X_train, y_train)        # Обучение модели
    y_predict = linear.predict(X_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 "Модель линейной регрессии", y_predict, mid_square, det_kp
 # Модель полиномиальной регрессии
 def poly_lr_prediction():
    poly = PolynomialFeatures(degree=4, include_bias=False)   # Создание характеристик полиномиальной модели (степень - 4, обнуление свободного члена - нет)
    x_poly_train = poly.fit_transform(X_train)                # Трансформация выборки обучения (добавление недостающих аргументов многочлена 4го порядка)
    x_poly_test = poly.fit_transform(X_test)                  # Трансформация тестовой выборки (добавление недостающих аргументов многочлена 4го порядка)
    linear = LinearRegression()                               # Создание модели
    linear.fit(x_poly_train, y_train)                         # Обучение модели
    y_predict = linear.predict(x_poly_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 "Модель полиномиальной регрессии", y_predict, mid_square, det_kp
 # Модель полиномиальной гребневой регрессии
 def poly_rg_prediction():
    poly = PolynomialFeatures(degree=4, include_bias=False)   # Создание характеристик полиномиальной модели (степень - 4, обнуление свободного члена - нет)
    x_poly_train = poly.fit_transform(X_train)                # Трансформация выборки обучения (добавление недостающих аргументов многочлена 4го порядка)
    x_poly_test = poly.fit_transform(X_test)                  # Трансформация тестовой выборки (добавление недостающих аргументов многочлена 4го порядка)
    ridge = Ridge(alpha=1.0)                                  # Создание гребневой модели (уср. коэф - 1.0)
    ridge.fit(x_poly_train, y_train)                          # Обучение модели
    y_predict = ridge.predict(x_poly_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 "Модель полиномиальной регрессии", y_predict, mid_square, det_kp
 # Создание графиков поотдельности (для себя)
 def make_plots(models):
    i = 0
    for model in models:
        plt.plot(y_test, c="red", label="\"y\" исходная")                          # Создание графика исходной функции
        plt.plot(model[1], c="green", label="\"y\" предсказанная \n"
                                                  "Ср^2 = " + str(model[2]) + "\n"
                                                  "Кд = " + str(model[3]))               # Создание графика предсказанной функции
        plt.legend(loc='lower left')
        plt.title(model[0])
        plt.savefig('static/' + str(i + 1) + '.png')
        plt.close()
        i += 1
 if __name__ == '__main__':
    models = lr_prediction(), poly_lr_prediction(), poly_rg_prediction()
    make_plots(models)
    fig, axs = plt.subplots(3, 1, layout='constrained')              # Создание общего графика для сравнения моделей
    i = 0
    for model in models:
        fig.set_figwidth(6)
        fig.set_figheight(10)
        axs[i].set_title(model[0])
        axs[i].plot(y_test, c="red", label="\"y\" исходная")
        axs[i].plot(model[1], c="green", label="\"y\" предсказанная \n"
                                               "Ср^2 = " + str(model[2]) + "\n"
                                               "Кд = " + str(model[3]))
        axs[i].legend(loc='lower left')
        i += 1
    plt.savefig('static/result.png')
--- a/arutunyan_dmitry_lab_1/result.png
+++ b/arutunyan_dmitry_lab_1/result.png
--- a/gordeeva_anna_lab_1/1graf.jpg
+++ b/gordeeva_anna_lab_1/1graf.jpg
--- a/gordeeva_anna_lab_1/2graf.jpg
+++ b/gordeeva_anna_lab_1/2graf.jpg
--- a/gordeeva_anna_lab_1/3graf.jpg
+++ b/gordeeva_anna_lab_1/3graf.jpg
--- a/gordeeva_anna_lab_1/lab1.py
+++ b/gordeeva_anna_lab_1/lab1.py
@ -1,66 +0,0 @@
 import streamlit as st
 import numpy as np
 from matplotlib import pyplot as plt
 from matplotlib.colors import ListedColormap
 from sklearn.model_selection import train_test_split
 from sklearn.preprocessing import StandardScaler
 from sklearn.datasets import make_moons, make_circles, make_classification
 from sklearn.linear_model import Perceptron
 from sklearn.neural_network import MLPClassifier
 from sklearn.metrics import accuracy_score
 st.header("Лабораторная работа 1. Вариант 7")
 #Создаем данные
 moon_dataset = make_moons(noise=0.3, random_state=0)
 X, y = moon_dataset #Х это двумерный массив с признаками (координатами), а y - одномерный массив с 0 и 1.(Либо к 1 классу, либо к другому)
 X = StandardScaler().fit_transform(X) #Данные нужно обязательно стандартизировать, для того, что бы один признак не перевешивал в обучении другой признак
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4, random_state=42) #Делим на обучающую и тестовую выборку. Число выбираем для того, чтобы выборка при каждом старте не менялась
 def print_perceptron(perceptron):
    # Обучение модели на обучающих данных
    perceptron.fit(X_train, y_train)
    #Определение точности модели
    y_pred = perceptron.predict(X_test)#На тестовой выборке получаем принадлежность к классу
    accuracy  = accuracy_score(y_test, y_pred)
    st.write("Точность:", accuracy)
    #График с помощью Matplotlib
    fig, ax = plt.subplots()
    cm_bright = ListedColormap(['#FF0000', '#0000FF'])
    cm_bright2 = ListedColormap(['#FFBBBB', '#BBBBFF'])
    cmap = ListedColormap(['#FFBBBB', '#BBBBFF'])
    #Отрисовка градиента/фона
    h = .02  # шаг регулярной сетки
    x0_min, x0_max = X_train[:, 0].min() - .5, X_train[:, 0].max() + .5 #Определение границы множества по оси х
    x1_min, x1_max = X_train[:, 1].min() - .5, X_train[:, 1].max() + .5 #Определение границы множества по оси y
    #np.arange(start, stop, inter) позволяет создать последовательность числен в интервале от start до stop c интервалом/шагом inter
    xx0, xx1 = np.meshgrid(np.arange(x0_min, x0_max, h), np.arange(x1_min, x1_max, h)) #получаем координатную матрицу из координатных векторов
    Z = perceptron.predict(np.c_[xx0.ravel(), xx1.ravel()])
    Z = Z.reshape(xx0.shape)  # Изменяем форму Z в соответствии с сеткой
    # Применяем обученную модель к сетке точек и отображаем результат как цветовую карту
    ax.contourf(xx0, xx1, Z, cmap=cmap, alpha=.8)
    scatter_train = ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright, marker='o', label='Обучающая выборка')
    scatter_test = ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright2, marker='x', label='Тестовая выборка')
    ax.legend(handles=[scatter_train, scatter_test], labels=['Обучающая выборка', 'Тестовая выборка'])
    st.pyplot(fig)
 # Создание объекта модели персептрона
 on = st.toggle('Персептрон')
 if on:
    perceptron = Perceptron(max_iter=100, random_state=0)
    print_perceptron(perceptron)
 # Создание объекта модели персептрона
 on = st.toggle('Многослойный персептрон с 10-ю нейронами в скрытом слое (alpha = 0.01)')
 if on:
    perceptron = MLPClassifier(hidden_layer_sizes=(10,), alpha=0.01, max_iter=1000, random_state=0)
    print_perceptron(perceptron)
 # Создание объекта модели персептрона
 on = st.toggle('Многослойный персептрон с 100-а нейронами в скрытом слое (alpha = 0.01)')
 if on:
    perceptron = MLPClassifier(hidden_layer_sizes=(100,), alpha=0.01, max_iter=1000, random_state=0)
    print_perceptron(perceptron)
--- a/gordeeva_anna_lab_1/readme.md
+++ b/gordeeva_anna_lab_1/readme.md
@ -1,63 +0,0 @@
 ## Задание
 Данные: make_moons (noise = 0.3, random_state = 0)
 Модели:
 * Персептрон
 * Многослойный персептрон с 10-ю нейронами в скрытом поле (alpha = 0.01)
 * Многослойный персептрон с 100-а нейронами в скрытом поле (alpha = 0.01)
 ## В чем различие каждой модели
 Персептрон:
 * самая простая форма искусственной нейронной сети
 * состоит из одного или нескольких нейронов
 * только один слой нейронов
 * разделяет данные линейно
 Многослойный персептрон с 10-ю/100-а нейронами в скрытом поле (alpha = 0.01)
 * более сложная форма искусственной нейронной сети
 * состоит из нескольких слоев, причем имеет один или несколько скрытых слоев
 * способен решать задачи классификации, регрессии, обработки изображений, текста и т.д
 Общий вывод таков, что многослойный персептрон способен решать более сложные задачи, требующие нелинейных решений.
 ## Библиотеки
 Streamlit. Предоставляет простой способ создания веб-приложений для визуализации данных.
 Numpy. Предоставляет возможность работать с массивами и матрицами.
 Matplotlib. Используется для создания графиков.
 Sklearn. Предоставляет инструменты и алгоритмы, которые упрощают задачи, связанные с машинным обучением.
 ## Функционал
 Предоставляет создание объекта для каждой модели персептрона.
 Создание данных с помощью функции make_moon c последующим
 делением данных на обучающую и тестовую выборку. 
 Метод print_perceptron, в котором происходит обучение модели, определение точности и отрисовка графика.
 ## Запуск
 Перед запуском необходимо запустить виртуальную среду venv. Так как я использую streamlit, то для запуска необходимо в терминал прописать следующую строку:
 ```
 streamlit run lab1.py
 ```
 Приложение развернется на локальном сервере и автоматически откроется в браузере.
 ## Скриншоты работы программы
 При запуске выглядит так:
 ![Alt text](win_start.jpg "Optional Title")
 Построенные графики
 ![Alt text](1graf.jpg "Optional Title")
 ![Alt text](2graf.jpg "Optional Title")
 ![Alt text](3graf.jpg "Optional Title")
 ## Вывод
 В первой модели, как сказано выше, данные делятся линейно. Но точность разделения близка к 1, поэтому задача в данном случае решена.
 В других моделях данные делятся нелинейно и чем выше кол-во нейронов, тем разбиение становится точнее. Но точность в обоих случаях одинаковая.
--- a/gordeeva_anna_lab_1/win_start.jpg
+++ b/gordeeva_anna_lab_1/win_start.jpg
--- a/labs.jpg
+++ b/labs.jpg
--- a/zavrazhnova_svetlana_lab_1/README.md
+++ b/zavrazhnova_svetlana_lab_1/README.md
@ -1,31 +0,0 @@
 ### Задание:
 Данные: make_classification (n_samples=500, n_features=2, n_redundant=0, n_informative=2, random_state=rs, n_clusters_per_class=1) 
 Модели:
 - Персептрон, 
 - Многослойный персептрон с 10-ю нейронами в скрытом слое (alpha = 0.01)
 - Многослойный персептрон со 100-а нейронами в скрытом слое (alpha = 0.01)
 ### как запустить лабораторную работу:
 Лабораторная работа запускается в файле `zavrazhnova_svetlana_lab_1.py` через Run, должно запуститься диалоговое окно и вычисления в консоли
 ### Технологии:
 Библиотека Scikit-learn содержит множество наборов данных
 ### Что делает лабораторная:
 Выполнение кода выводит точность каждой модели (в консоль) и отображает графики с границами решений для каждой модели.
 В данном коде генерируются данные с использованием функции make_classification() из библиотеки scikit-learn. Генерируется набор данных с 500 примерами и 2 признаками. Классы точек представлены переменной y, которая содержит метки классов для каждой точки. В данном случае, сгенерировано два класса, обозначенных как 0 и 1.
 Визуализация данных и границ решения моделей выполняется с помощью функции scatter() и функции contourf() из библиотеки matplotlib. Функция scatter() отображает точки данных на графике, окрашивая их в соответствии с классами, заданными переменной y.
 Таким образом, графики помогают визуализировать данные, их классификацию и границы решения моделей, позволяя лучше понять, как модели принимают решение о классификации объектов.
 ### Пример выходных значений:
 Консоль:
 ![результат в консоль](imgConsoleRes.png)
 Графики:
 ![img.png](imgGraphicsRes.png)
--- a/zavrazhnova_svetlana_lab_1/imgConsoleRes.png
+++ b/zavrazhnova_svetlana_lab_1/imgConsoleRes.png
--- a/zavrazhnova_svetlana_lab_1/imgGraphicsRes.png
+++ b/zavrazhnova_svetlana_lab_1/imgGraphicsRes.png
--- a/zavrazhnova_svetlana_lab_1/zavrazhnova_svetlana_lab_1.py
+++ b/zavrazhnova_svetlana_lab_1/zavrazhnova_svetlana_lab_1.py
@ -1,89 +0,0 @@
 import numpy as np
 from sklearn.datasets import make_classification
 from sklearn.model_selection import train_test_split
 from sklearn.linear_model import Perceptron
 from sklearn.neural_network import MLPClassifier
 from sklearn.metrics import accuracy_score
 from matplotlib import pyplot as plt
 #Задание случайного состояния
 rs = 42
 #Генерируются 500 примеров с 2 признаками, 0 лишними признаками, 2 информативными признаками,
 # random_state устанавливается в rs для воспроизводимости данных и n_clusters_per_class устанавливается в 1 для генерации одного кластера классов
 X, y = make_classification(n_samples=500, n_features=2, n_redundant=0, n_informative=2, random_state=rs, n_clusters_per_class=1)
 # Разделение данных на обучающую и тестовую выборки
 #test_size установлен на 0.4, что означает, что 40% данных будет использовано для тестирования.
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=rs)
 # Инициализация моделей
 perceptron = Perceptron()
 mlp_10 = MLPClassifier(hidden_layer_sizes=(10,), alpha=0.01, random_state=rs)
 mlp_100 = MLPClassifier(hidden_layer_sizes=(100,), alpha=0.01, random_state=rs)
 # Обучение моделей
 perceptron.fit(X_train, y_train)
 mlp_10.fit(X_train, y_train)
 mlp_100.fit(X_train, y_train)
 # Предсказание на тестовой выборке
 y_pred_perceptron = perceptron.predict(X_test)
 y_pred_mlp_10 = mlp_10.predict(X_test)
 y_pred_mlp_100 = mlp_100.predict(X_test)
 # Оценка качества моделей, Оценка точности (accuracy) каждой модели сравнивается с истинными метками классов на тестовой выборке
 accuracy_perceptron = accuracy_score(y_test, y_pred_perceptron)
 accuracy_mlp_10 = accuracy_score(y_test, y_pred_mlp_10)
 accuracy_mlp_100 = accuracy_score(y_test, y_pred_mlp_100)
 # Вывод результатов
 print("Точность - Perceptron:", accuracy_perceptron)
 print("Точность - MLP (10 neurons):", accuracy_mlp_10)
 print("Точность - MLP (100 neurons):", accuracy_mlp_100)
 # Визуализация данных и границ решения моделей
 #Определение интервала значений для графиков, чтобы включить все точки данных и оставить небольшую дополнительную поверхность вокруг границы графика
 x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
 y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
 xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),
                     np.arange(y_min, y_max, 0.02))
 #Предсказание класса для каждой точки в сетке графика и изменение формы результата, чтобы соответствовать размерам сетки
 Z_perceptron = perceptron.predict(np.c_[xx.ravel(), yy.ravel()])
 Z_perceptron = Z_perceptron.reshape(xx.shape)
 Z_mlp_10 = mlp_10.predict(np.c_[xx.ravel(), yy.ravel()])
 Z_mlp_10 = Z_mlp_10.reshape(xx.shape)
 Z_mlp_100 = mlp_100.predict(np.c_[xx.ravel(), yy.ravel()])
 Z_mlp_100 = Z_mlp_100.reshape(xx.shape)
 #Визуализация данных и границ решения моделей на трех графиках.
 # Границы решения отмечены заштрихованными областями, а точки данных на графике окрашены в соответствии с их классами
 plt.figure(figsize=(12, 9))
 plt.subplot(221)
 plt.contourf(xx, yy, Z_perceptron, 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()
--- a/zavrazhnova_svetlana_lab_2/README.md
+++ b/zavrazhnova_svetlana_lab_2/README.md
@ -1,30 +0,0 @@
 ### Задание по варианту
 Лассо (Lasso),Сокращение признаков Случайными деревьями (Random Forest Regressor), Линейная корреляция (f_regression)
 ### Как запустить лабораторную работу
 ЛР запускается через файл `zavrazhnova_svetlana_lab_2.py` 
 ### Какие технологии использовали
 импорт класса `MinMaxScaler`, выполняющего масштабирование данных до заданного диапазона (от 0 до 1).
 Необходимость его использования объясняется следующим: каждая модель регрессии дает оценки
 важности признаков в своем диапазоне. Для того чтобы найти признак с максимальной средней важностью по трем моделям, нам необходимо привести выданные ими оценки к одному виду.
 Модели линейной регрессии, ридж-регрессии и лассо-регрессии из библиотеки `scikit-learn`
 ### Что делает
 Применение регрессионных моделей для определения важности признаков.
 Результат работы программы показывает ранжирование признаков по их значимости для задачи. Чем больше значение ранга, тем более значимый признак.
 Полученные ранги можно использовать для отбора наиболее значимых признаков и сокращения размерности данных.
 ### Примеры выходных значений
 ![example program result](result.png)
 В данном случае, в соответствии с полученными результатами, можно сказать следующее:
 1. Признаки 'x4' и 'x14' имеют наивысшие ранги (больше 380), что указывает на их большую значимость в решении задачи.
 2. Признаки 'x2' и 'x12' имеют средние ранги (от 170 до 180), что означает их среднюю значимость.
 3. Признаки 'x1' и 'x11' имеют ранги около 120, что указывает на их относительную значимость.
 4. Признаки 'x5', 'x8' и 'x7' имеют низкие ранги (от 5 до 17), что говорит о их низкой значимости.
 5. Признаки 'x9', 'x3', 'x13', 'x10' и 'x6' имеют очень низкие ранги (меньше 3), что указывает на их минимальную значимость или наличие практически нулевых эффектов.
--- a/zavrazhnova_svetlana_lab_2/result.png
+++ b/zavrazhnova_svetlana_lab_2/result.png
--- a/zavrazhnova_svetlana_lab_2/zavrazhnova_svetlana_lab_2.py
+++ b/zavrazhnova_svetlana_lab_2/zavrazhnova_svetlana_lab_2.py
@ -1,54 +0,0 @@
 from sklearn.linear_model import Lasso
 from sklearn.ensemble import RandomForestRegressor
 from sklearn.feature_selection import f_regression
 from sklearn.preprocessing import MinMaxScaler
 import numpy as np
 np.random.seed(0)
 size = 750
 #входные данные.
 X = np.random.uniform(0, 1, (size, 14))
 #Генерируется целевая переменная Y на основе математической функции от входных данных X.
 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)]
 #Создается пустой словарь для хранения рангов признаков
 ranks = {}
 #Создается экземпляр модели лассо-регрессии
 lasso = Lasso(alpha=.05)
 #Модель подгоняется под входные данные X и целевую переменную Y
 lasso.fit(X, Y)
 ranks["Lasso"] = dict(zip(names, lasso.coef_))
 rf = RandomForestRegressor(n_estimators=100, random_state=0)
 rf.fit(X, Y)
 ranks["Random Forest"] = dict(zip(names, rf.feature_importances_))
 f, _ = f_regression(X, Y, center=True)
 ranks["f_regression"] = dict(zip(names, f))
 def rank_to_dict(ranks, names):
    ranks = np.abs(ranks)
    minmax = MinMaxScaler()
    #масштабирование рангов с помощью MinMaxScaler
    ranks = minmax.fit_transform(np.array(ranks).reshape(-1, 1)).ravel()
    ranks = map(lambda x: round(x, 2), ranks)
    return dict(zip(names, ranks))
 #словарь для хранения средних рангов признаков
 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]
 sorted_mean = sorted(mean.items(), key=lambda x: x[1], reverse=True)
 result = {}
 for item in sorted_mean:
    result[item[0]] = item[1]
    print(f'{item[0]}: {item[1]}')
--- a/МетодичкаМИИ_МО-1.pdf
+++ b/МетодичкаМИИ_МО-1.pdf