martysheva lab2 done

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

.idea/.gitignore

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

.idea/IIS_2023_1.iml

@@ -0,0 +1,8 @@
+<?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>

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

.idea/misc.xml

@@ -0,0 +1,4 @@
+<?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>

.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/IIS_2023_1.iml" filepath="$PROJECT_DIR$/.idea/IIS_2023_1.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

.idea/workspace.xml

@@ -0,0 +1,135 @@
+<?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="" />
+    <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/labs"
+  }
+}]]></component>
+  <component name="RecentsManager">
+    <key name="CopyFile.RECENT_KEYS">
+      <recent name="D:\ulstukek\Course4\IIS\IISLabs\IIS_2023_1\zavrazhnova_svetlana_lab_3" />
+      <recent name="D:\ulstukek\Course4\IIS\IISLabs\IIS_2023_1\zavrazhnova_svetlana_lab_1" />
+    </key>
+  </component>
+  <component name="RunManager" selected="Python.zavrazhnova_svetlana_lab3_2">
+    <configuration name="zavrazhnova_svetlana_lab3_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_3" />
+      <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_3/zavrazhnova_svetlana_lab3_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>
+    <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>
+    <configuration name="zavrazhnova_svetlana_lab_3_1" 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_3" />
+      <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_3/zavrazhnova_svetlana_lab_3_1.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_lab3_2" />
+        <item itemvalue="Python.zavrazhnova_svetlana_lab_3_1" />
+        <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>

README.md

@@ -46,12 +46,12 @@ P.S. я знаю про хак "хочу скопировать у товари
 
 4. Как только Вы закончили работу над лабораторной работой, то находясь в своей ветке (убедитесь в этом пожалуйста, использую команду git branch - ваша текущая ветка будет подсвечена), вы должны закоммитить и запушить свои изменения в репозиторий, другими словами сохранить их в репозиторий.
 
-- git commit -m "zhelepov_alex_lab_1 is ready"
-- git push origin
+> git commit -m "zhelepov_alex_lab_1 is ready"
+> git push origin
 
 P.S. я знаю про хак "скопируй у товарища и закоммить - все равно он (я) смотреть не будет" - не сработает - давайте быть честными и делать все самостоятельно. А во-вторых, на реальной работе так не прокатит - скорее всего Вас просто уволят.
 
-5. После этого Вы должны перейти в наш gitlab и создать merge request, назначив его на меня. Дополнительно лучше маякнуть меня в нашем [телеграм-чате](https://t.me/+XSq2xEbEuD05N2Vi). Я проведу ревью и отпишу замечания, которые нужно будет исправить. Если все хорошо, то вмержу ваш pull-request в мастер-ветку. Данное состояние говорит о том, что ваша л/р принята.
+5. После этого Вы должны перейти в наш git и создать merge request, назначив его на меня. Дополнительно лучше маякнуть меня в нашем [телеграм-чате](https://t.me/+XSq2xEbEuD05N2Vi). Я проведу ревью и отпишу замечания, которые нужно будет исправить. Если все хорошо, то вмержу ваш pull-request в мастер-ветку. Данное состояние говорит о том, что ваша л/р принята.
 
 6. **Важный момент**: Устно я не принимаю лабораторные работы (подойти к компьютеру, посмотреть код, поставить оценку), только через репозиторий и после успешного code review ревью кода вашей л/р и ее результатов в виде отчета. Это делается для того, чтобы вы привыкали к воркфлоу, который применяется практически всеми IT-компаниями, где между разработчиками в основном общение идет через "текст". Что касается лабораторных работ в расписании - они используются в качестве консультаций, а сдача и проверка л/р идет только через репозиторий (то есть все замечания вы получаете на code review). Проверяю я обычно лабораторную в течение 1-3 дней после создания pull-request-а (всегда можно маякнуть меня в нашем telegram-чате).
 

alexandrov_dmitrii_lab_1/lab1.py

@@ -0,0 +1,56 @@
+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()

alexandrov_dmitrii_lab_1/readme.md

@@ -0,0 +1,46 @@
+## Задание
+Сгенерировать определенный тип данных и сравнить на нем 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, что результирует в малом эффекте гребневой функции.

alexandrov_dmitrii_lab_2/lab2.py

@@ -0,0 +1,82 @@
+from sklearn.linear_model import LinearRegression, RandomizedLasso
+from sklearn.feature_selection import RFE
+from sklearn.preprocessing import MinMaxScaler
+from matplotlib import pyplot as plt
+import numpy as np
+import random as rand
+
+figure = plt.figure(1, figsize=(16, 9))
+axis = figure.subplots(1, 4)
+col = 0
+y = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
+
+
+def rank_to_dict(ranks, names, n_features):
+    ranks = np.abs(ranks)
+    minmax = MinMaxScaler()
+    ranks = minmax.fit_transform(np.array(ranks).reshape(n_features, 1)).ravel()
+    ranks = map(lambda x: round(x, 2), ranks)
+    return dict(zip(names, ranks))
+
+
+def createView(key, val):
+    global figure
+    global axis
+    global col
+    global y
+
+    axis[col].bar(y, list(val.values()), label=key)
+    axis[col].set_title(key)
+
+    col = col + 1
+
+
+def start():
+    np.random.seed(rand.randint(0, 50))
+    size = 750
+    n_features = 14
+    X = np.random.uniform(0, 1, (size, n_features))
+
+    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))
+
+    lr = LinearRegression()
+    rl = RandomizedLasso()
+    rfe = RFE(estimator=LinearRegression(), n_features_to_select=1)
+    lr.fit(X, Y)
+    rl.fit(X, Y)
+    rfe.fit(X, Y)
+
+    names = ["x%s" % i for i in range(1, n_features + 1)]
+    rfe_res = rfe.ranking_
+    for i in range(rfe_res.size):
+        rfe_res[i] = 14 - rfe_res[i]
+    ranks = {"Linear regression": rank_to_dict(lr.coef_, names, n_features),
+             "Random lasso": rank_to_dict(rl.scores_, names, n_features),
+             "RFE": rank_to_dict(rfe_res, names, n_features)}
+
+    mean = {}
+
+    for key, value in ranks.items():
+        for item in value.items():
+            if item[0] not in mean:
+                mean[item[0]] = 0
+            mean[item[0]] += item[1]
+
+    for key, value in mean.items():
+        res = value / len(ranks)
+        mean[key] = round(res, 2)
+
+    ranks["Mean"] = mean
+
+    for key, value in ranks.items():
+        createView(key, value)
+        ranks[key] = sorted(value.items(), key=lambda y: y[1], reverse=True)
+    for key, value in ranks.items():
+        print(key)
+        print(value)
+
+
+start()
+plt.show()

alexandrov_dmitrii_lab_2/readme.md

@@ -0,0 +1,50 @@
+### Задание
+Выполнить ранжирование признаков с помощью указанных по варианту моделей. Отобразить получившиеся значения\оценки каждого признака каждым методом\моделью и среднюю оценку. Провести анализ получившихся результатов. Определить, какие четыре признака оказались самыми важными по среднему значению.
+
+Вариант 1.
+Модели:
+* Линейная регрессия (LinearRegression)
+* Случайное Лассо (RandomizedLasso)
+* Рекурсивное сокращение признаков (Recursive Feature Elimination – RFE) 
+
+### Запуск программы
+Программа работает на Python 3.7, поскольку только в нём можно подключить нужную версию библиотеки scikit-learn, которая ещё содержит RandomizedLasso.
+
+Файл lab2.py содержит и запускает программу, аргументов и настройки ~~вроде~~ не требует.
+
+### Описание программы
+Файл lab2.py содержит непосредственно программу.
+
+Программа создаёт набор данных с 10 признаками для последующего их ранжирования, и обрабатывает тремя моделями по варианту.
+Программа строит столбчатые диаграммы, которые показывают как распределились оценки важности признаков, и выводит в консоль отсортированные по убыванию важности признаки.
+Таким образом можно легко определить наиважнейшие признаки.
+
+### Результаты тестирования
+По результатам тестирования, можно сказать следующее:
+* линейная регрессия показывает хорошие результаты, выделяет все 9 значимых признаков.
+* случайное лассо справляется хуже других моделей, иногда выделяя шумовые признаки в значимые, а значимые - в шумовые.
+* рекурсивное сокращение признаков показывает хорошие результаты, правильно правильно выделяя 9 самых значимых признаков.
+* хотя линейная регрессия и рекурсивное сокращение признаков правильно выделяют значимые признаки, саму значимость они оценивают по-разному.
+* среднее значение позволяет c хорошей уверенностью определять истинные значимые признаки.
+
+Итого. Если необходимо просто ранжирование, достаточно взять модель RFE, однако, если необходимо анализировать признаки по коэффициентам, имея меру (коэффициенты), то брать нужно линейную регрессию. Случайное лассо лучше не надо.
+
+Пример консольных результатов:
+
+>Linear regression
+
+>[('x1', 1.0), ('x4', 0.69), ('x2', 0.61), ('x11', 0.59), ('x3', 0.51), ('x13', 0.48), ('x5', 0.19), ('x12', 0.19), ('x14', 0.12), ('x8', 0.03), ('x6', 0.02), ('x10', 0.01), ('x7', 0.0), ('x9', 0.0)]
+
+>Random lasso
+
+>[('x5', 1.0), ('x4', 0.76), ('x2', 0.74), ('x1', 0.72), ('x14', 0.44), ('x12', 0.32), ('x11', 0.28), ('x8', 0.22), ('x6', 0.17), ('x3', 0.08), ('x7', 0.02), ('x13', 0.02), ('x9', 0.01), ('x10', 0.0)]
+
+>RFE
+
+>[('x4', 1.0), ('x1', 0.92), ('x11', 0.85), ('x2', 0.77), ('x3', 0.69), ('x13', 0.62), ('x5', 0.54), ('x12', 0.46), ('x14', 0.38), ('x8', 0.31), ('x6', 0.23), ('x10', 0.15), ('x7', 0.08), ('x9', 0.0)]
+
+>Mean
+
+>[('x1', 0.88), ('x4', 0.82), ('x2', 0.71), ('x5', 0.58), ('x11', 0.57), ('x3', 0.43), ('x13', 0.37), ('x12', 0.32), ('x14', 0.31), ('x8', 0.19), ('x6', 0.14), ('x10', 0.05), ('x7', 0.03), ('x9', 0.0)]
+
+По данным результатам можно заключить, что наиболее влиятельные признаки по убыванию: x1, x4, x2, x5.

almukhammetov_bulat_lab_1/README.md

@@ -0,0 +1,53 @@
+Вариант 2
+
+Задание:
+Используя   код   из   пункта «Регуляризация   и   сеть   прямого распространения «из [1] (стр. 228), сгенерируйте определенный тип данных и сравните на нем 3 модели (по варианту)Постройте графики, отобразите качество моделей, объясните полученные результаты.
+
+Данные: 
+make_circles (noise=0.2, factor=0.5, random_state=rs) Модели: · Линейную регрессию · Полиномиальную регрессию (со степенью 3) · Гребневую полиномиальную регрессию (со степенью 3, alpha= 1.0)
+
+Запуск:
+Запустите файл lab1.py
+
+Описание программы:
+1.	Генерирует набор данных с использованием функции make_circles из scikit-learn. Этот набор данных представляет собой два класса, где точки одного класса окружают точки другого класса с добавленным шумом.
+2.	Разделяет данные на обучающий и тестовый наборы с помощью функции train_test_split.
+3.	Создает три разные модели для классификации данных:
+4.	Линейная регрессия (Logistic Regression).
+5.	Полиномиальная регрессия третьей степени (Polynomial Regression).
+6.	Гребневая полиномиальная регрессия третьей степени с регуляризацией и альфой равной единице (Ridge Polynomial Regression).
+7.	Обучаем каждую из этих моделей на обучающем наборе данных и оцениваем их точность на тестовом наборе данных.
+8.	Выводит результаты точности каждой модели.
+9.	Разделение областей предсказаний моделей (границы решения).
+10.	Тестовые и обучающие точки, окрашенные в соответствии с классами. (красным и синим)
+
+Результаты:
+
+<p>
+    <div>Точность</div>
+    <img src="Рисунок1.png">
+</p>
+
+<p>
+    <div>Графики регрессии</div>
+    <img src="Рисунок2.png">
+    <img src="Рисунок3.png">
+    <img src="Рисунок4.png">
+</p>
+
+
+Исходя из получивших графиков и точночсти с данным типом генерации данных из этих трех моделей наиболее точной получились полиномиальную регрессия (со степенью 3) и гребневaz полиномиальная регрессия (со степенью 3, alpha= 1.0). Они так же являются идентичными между собой. Чтобы проверить это утверждение я провел дополнительное тестирование и написал скрипт, который для 10 разных random_state (2-11) вычисляет точность для трех разных моделей. 
+
+Результаты:
+
+Значения точности для каждой модели:
+Линейная регрессия	0.40	0.52	0.44	0.56	0.48	0.49	0.50	0.49	0.46	0.40
+Полиномиальная регрессия (со степенью 3)	0.63	0.67	0.74	0.64	0.80	0.73	0.64	0.81	0.46	0.62
+Гребневая полиномиальная регрессия (со степенью 3, alpha = 1.0)	0.63	0.67	0.74	0.64	0.80	0.73	0.64	0.81	0.46	0.62
+
+Средние значения точности:
+Линейная регрессия - Средняя точность: 0.47
+Полиномиальная регрессия (со степенью 3) - Средняя точность: 0.68
+Гребневая полиномиальная регрессия (со степенью 3, alpha = 1.0) - Средняя точность: 0.68
+
+Утверждение также подтвердилось.

almukhammetov_bulat_lab_1/lab1.py

@@ -0,0 +1,83 @@
+import numpy as np
+from matplotlib import pyplot as plt
+from matplotlib.colors import ListedColormap
+from sklearn.datasets import make_circles
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score
+from sklearn.model_selection import train_test_split
+from sklearn.pipeline import make_pipeline
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.preprocessing import StandardScaler
+
+# Используя код из пункта «Регуляризация и сеть прямого распространения»из [1](стр. 228),
+# сгенерируйте определенный тип данных и сравните на нем 3 модели (по варианту).
+# Постройте  графики, отобразите качество моделей, объясните полученные результаты.
+
+# Модели
+# Линейная регрессия
+# Полиномиальная регрессия (со степенью 3)
+# Гребневую полиномиальную регрессию (со степенью 3, alpha = 1.0)
+
+# Данные
+# make_circles (noise=0.2, factor=0.5, random_state=rs)
+
+random_state = np.random.RandomState(2)
+
+# Генерируем датасет
+circles_dataset = make_circles(noise=0.2, factor=0.5, random_state=random_state)
+
+X, y = circles_dataset
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.9, random_state=random_state)
+
+# Создаем модели
+models = []
+
+# Линейная регрессия
+linear_model = LogisticRegression(random_state=random_state)
+models.append(("Линейная регрессия", linear_model))
+
+# Полиномиальная регрессия (со степенью 3)
+poly_model = make_pipeline(PolynomialFeatures(degree=3), StandardScaler(),
+                           LogisticRegression(random_state=random_state))
+models.append(("Полиномиальная регрессия (со степенью 3)", poly_model))
+
+# Гребневая полиномиальная регрессия (со степенью 3 и alpha=1.0)
+ridge_poly_model = make_pipeline(PolynomialFeatures(degree=3), StandardScaler(),
+                                 LogisticRegression(penalty='l2', C=1.0, random_state=random_state))
+models.append(("Гребневая полиномиальная регрессия (со степенью 3, alpha = 1.0)", ridge_poly_model))
+
+# Обучаем и оцениваем модели
+results = []
+
+for name, model in models:
+    model.fit(X_train, y_train)  # обучаем
+    y_pred = model.predict(X_test)  # предсказываем
+    accuracy = accuracy_score(y_test, y_pred)  # определяем точность
+    results.append((name, accuracy))
+
+# Выводим результаты
+for name, accuracy in results:
+    print(f"{name} - Точность: {accuracy:.2f}")
+
+# Строим графики
+cmap_background = ListedColormap(['#FFAAAA', '#AAAAFF'])
+cmap_points = ListedColormap(['#FF0000', '#0000FF'])
+
+plt.figure(figsize=(15, 5))
+for i, (name, model) in enumerate(models):
+    plt.subplot(1, 3, i + 1)
+    xx, yy = np.meshgrid(np.linspace(X[:, 0].min() - 1, X[:, 0].max() + 1, 100),
+                         np.linspace(X[:, 1].min() - 1, X[:, 1].max() + 1, 100))
+    Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
+    Z = Z.reshape(xx.shape)
+    plt.contourf(xx, yy, Z, cmap=cmap_background, alpha=0.5)
+    plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cmap_points, marker='o', label='Тестовые точки')
+    plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cmap_points, marker='x', label='Обучающие точки')
+    plt.legend()
+    plt.title(name)
+
+    plt.text(0.5, -1.2, 'Красный класс', color='r', fontsize=12)
+    plt.text(0.5, -1.7, 'Синий класс', color='b', fontsize=12)
+
+plt.tight_layout()
+plt.show()

antonov_dmitry_lab_1/README.md

@@ -0,0 +1,97 @@
+# Лаб 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>

antonov_dmitry_lab_1/lab1.py

@@ -0,0 +1,97 @@
+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)
+

antonov_dmitry_lab_3/README.md

@@ -0,0 +1,85 @@
+# Лаб 3
+
+Деревья решений
+
+Часть 1. По данным о пассажирах Титаника решите задачу классификации
+(с помощью дерева решений), в которой по различным характеристикам
+пассажиров требуется найти у выживших пассажиров два наиболее важных
+признака из трех рассматриваемых (по варианту). Пример решения задачи
+можно посмотреть здесь: [1] (стр.188). Скачать данные можно по ссылке:
+https://www.kaggle.com/datasets/heptapod/titanic
+
+Часть 2. Решите с помощью библиотечной реализации дерева решений
+задачу из лабораторной работы «Веб-сервис «Дерево решений» по предмету
+«Методы искусственного интеллекта» на 99% ваших данных. Проверьте
+работу модели на оставшемся проценте, сделайте вывод.
+
+# Вариант 3
+
+Признаки Sex,Age,SibSp
+
+# Запуск
+
+Выполнением скрипта файла (вывод в консоль).
+
+# Описание модели:
+
+DecisionTreeClassifier - это алгоритм машинного обучения, используемый для задач классификации и регрессии.
+Он представляет собой дерево решений, где на каждом узле дерева решается, какой вопрос задать дальше 
+(признак для дальнейшего разбиения данных), а в листьях находятся окончательные ответы.
+
+# Результаты
+
+На данных для Титаника модель определяет важность признаков с точность 75% (исключает 'sibsp').
+Эти два признака обладают статистической важностью.
+<p>
+    <div>Титаник</div>
+    <img src="screens/titanic.png" width="650" title="Титаник 1">
+</p>
+
+На данных моего датасета модель справляется на 52.768%, если в качестве предлагаемых параметров
+на вход идут ['Gender', 'Debtor', 'International'] (исключает 'International').
+
+<p>
+    <div>Мой датасет 1</div>
+    <img src="screens/mydataset1.png" width="650" title="Мой датасет 1">
+</p>
+
+И на 70.961, если на вход идут ['Gender', 'Debtor', 'Curricular units 2nd sem (approved)']
+(исключает 'Gender'). 
+
+<p>
+    <div>Мой датасет 2</div>
+    <img src="screens/mydataset2.png" width="650" title="Мой датасет 2">
+</p>
+
+Такой результат можно объяснить большей значимостью признака 'Curricular units 2nd sem (approved)' 
+вместо 'International' (было показано в предыдущей лабораторной).
+
+Из-за того, что мы взяли статистически более значимый признак, модель выдает нам большую точность.
+
+Точность 52.768% указывает на то, что модель работает на уровне случайности, что означает, что она 
+работает не лучше, чем случайное угадывание. Для этого может быть несколько причин:
+
+1. Признаки все имеет малое значение: то есть для сравнения подаются признаки статистически малозначимые. 
+
+2. Недостаточно данных: Набор данных может содержать недостаточно информации или примеров для 
+изучения моделью. Если набор данных невелик или нерепрезентативен, модель, возможно, не сможет 
+хорошо обобщить новые данные.
+
+3. Несбалансированные классы: Если классы в вашей целевой переменной несбалансированы 
+(например, случаев, не связанных с отсевом, гораздо больше, чем случаев отсева), модель может 
+быть смещена в сторону прогнозирования класса большинства.
+
+4. Переобучение: Модель может быть переобучена обучающими данным, что означает, что она изучает шум 
+в данных, а не лежащие в их основе закономерности. Это может произойти, если модель слишком сложна по 
+сравнению с объемом доступных данных.
+
+5. Недостаточное соответствие: С другой стороны, модель может быть слишком простой, чтобы отразить 
+взаимосвязи в данных. Важно выбрать соответствующий уровень сложности модели.
+
+<div>
+При отборе признаков должна учитываться их статистическая значимость, вычисленная различными способами
+(например с помощью лин регрессии, Random Forest Regressor, линейной корреляции f_regression или других).
+Так же должно быть достаточно данных, в модели должно быть сведено к минимуму переобучение.
+</div>

antonov_dmitry_lab_3/lab3.py

@@ -0,0 +1,35 @@
+import pandas as pd
+from sklearn.metrics import accuracy_score
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeClassifier
+
+# прочитали датасет
+data = pd.read_csv('dataset.csv')
+
+# определение признаков
+# целевая переменная - Target
+X = data[['Gender', 'Debtor', 'Curricular units 2nd sem (approved)']]
+y = data['Target']  # Assuming 'Dropout' is the target variable
+
+# разделили данные на тренировочную и тестовую выборки
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# создали модель decision tree classifier
+dt_classifier = DecisionTreeClassifier(random_state=42)
+dt_classifier.fit(X_train, y_train)
+
+# получили значения модели для 2ух самых важных признаков
+feature_importances = dt_classifier.feature_importances_
+
+top_features_indices = feature_importances.argsort()[-2:][::-1]
+top_features = X.columns[top_features_indices]
+
+# вывод результата
+print("2 самых важных признака:", top_features)
+
+# получили значения модели для проверки точности
+predictions = dt_classifier.predict(X_test)
+
+# вычислили точность модели
+accuracy = accuracy_score(y_test, predictions)
+print("точность модели:", accuracy)

antonov_dmitry_lab_3/titanic.py

@@ -0,0 +1,40 @@
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.metrics import accuracy_score
+
+# прочитали датасет
+data = pd.read_csv("titanic_data.csv")
+
+# определение признаков
+features = ['Sex', 'Age', 'sibsp']
+
+# целевая переменная - выжившие
+target = 'Survived'
+
+# разделили данные на тренировочную и тестовую выборки
+train_data, test_data, train_labels, test_labels = train_test_split(
+    data[features],
+    data[target],
+    test_size=0.2,
+    random_state=42
+)
+
+# создали модель decision tree classifier
+model = DecisionTreeClassifier()
+
+# натренировали модель
+model.fit(train_data, train_labels)
+
+# получили значения модели для проверки точности
+predictions = model.predict(test_data)
+
+# вычислили точность модели
+accuracy = accuracy_score(test_labels, predictions)
+print("точность модели:", accuracy)
+
+# нашли два самых важных признака
+importances = model.feature_importances_
+indices = (-importances).argsort()[:2]
+important_features = [features[i] for i in indices]
+print("два самых важных признака:", important_features)

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 "")
+
+### Вывод
+Наиболее низкое среднеквадратичное отклонение и наиболее высокий коэфициент детерминации показала модель линейной регрессии, а это значит что она наилучшем образом подходит для работы со сгенерированным данными. В этом случае мы можем предположить что данные выборки находятся на небольшом расстоянии друг от друга и располагаются линейно.

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')
+
+

gordeeva_anna_lab_1/lab1.py

@@ -0,0 +1,66 @@
+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)

gordeeva_anna_lab_1/readme.md

@@ -0,0 +1,63 @@
+## Задание
+Данные: 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, поэтому задача в данном случае решена.
+В других моделях данные делятся нелинейно и чем выше кол-во нейронов, тем разбиение становится точнее. Но точность в обоих случаях одинаковая.

gusev_vladislav_lab_1/README.md

@@ -0,0 +1,28 @@
+### Вариант 9
+### Задание на лабораторную работу:
+По данным, построить графики 3 моделей:
+- Персептрон  
+- Многослойный персептрон с 10-ю нейронами в скрытом слое (alpha = 0.01) 
+- Многослойный персептрон с 100-а нейронами в скрытом слое (alpha = 0.01)
+
+Данные: make_classification (n_samples=500, n_features=2, n_redundant=0, n_informative=2, random_state=rs, n_clusters_per_class=1) 
+
+### Как запустить лабораторную работу:
+Выполняем файл gusev_vladislav_lab_1.py, на экране будет нарисовано 3 графика
+
+### Технологии
+NumPy - библиотека для работы с многомерными массивами. Mathplotlib - библиотека для визуализации данных двумерной и трехмерной графикой. Sklearn - библиотека с большим количеством алгоритмов машинного обучения.
+
+### По коду
+Используем функцию make_classification, чтобы сгенерировать 500 примеров с 2 признаками. Дополнительные параметры определяют характеристики данных, такие как количество информативных признаков и случайное распределение классов.
+
+С помощью train_test_split разделяем данные на обучающую и тестовую выборки в соотношении 70% к 30%.
+
+Далее создаются 3 модели: персептрон, многослойный персептрон с 10 нейронами в скрытом слое и многослойный персептрон с 100 нейронами в скрытом слое.Модели обучаются на обучающих данных с использованием метода fit.
+
+Обученные модели используются для предсказания классов на тестовых данных с помощью метода predict.
+Затем с помощью accuracy_score оцениваем точности предсказаний моделей на тестовом наборе данных.
+
+Далее создаем графики для каждой модели, где каждая точка данных отображается на графике с цветом, соответствующим предсказанному классу. В заголовках написана точность для каждой модели. Отображаем графики с помощью plt.show().
+
+Полученные графики: ![Figure_1.png](Figure_1.png)

gusev_vladislav_lab_1/gusev_vladislav_lab_1.py

@@ -0,0 +1,55 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.datasets import make_classification
+from sklearn.linear_model import Perceptron
+from sklearn.neural_network import MLPClassifier
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
+
+# Создание искусственных данных
+rs = np.random.RandomState(42)
+#n_samples - число примеров, n_features - признаки, n_redindant - лишние признаки, n_informative - информативные признаки
+#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.3 - 30% тестов
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=rs)
+
+# Модель персептрона
+perceptron = Perceptron()
+perceptron.fit(X_train, y_train)
+y_pred_perceptron = perceptron.predict(X_test)
+accuracy_perceptron = accuracy_score(y_test, y_pred_perceptron)
+
+# Модель многослойного персептрона с 10 нейронами
+mlp_10 = MLPClassifier(hidden_layer_sizes=(10,), alpha=0.01, random_state=rs)
+mlp_10.fit(X_train, y_train)
+y_pred_mlp_10 = mlp_10.predict(X_test)
+accuracy_mlp_10 = accuracy_score(y_test, y_pred_mlp_10)
+
+# Модель многослойного персептрона с 100 нейронами
+mlp_100 = MLPClassifier(hidden_layer_sizes=(100,), alpha=0.01, random_state=rs)
+mlp_100.fit(X_train, y_train)
+y_pred_mlp_100 = mlp_100.predict(X_test)
+accuracy_mlp_100 = accuracy_score(y_test, y_pred_mlp_100)
+
+# Визуализация данных
+plt.figure(figsize=(12, 4))
+
+# Персептрон
+plt.subplot(131)
+plt.scatter(X_test[:, 0], X_test[:, 1], c=y_pred_perceptron, cmap=plt.cm.Paired)
+plt.title(f'Персептрон (Точность: {accuracy_perceptron:.2f})')
+
+# Многослойный персептрон с 10 нейронами
+plt.subplot(132)
+plt.scatter(X_test[:, 0], X_test[:, 1], c=y_pred_mlp_10, cmap=plt.cm.Paired)
+plt.title(f'MLP (10 нейронов) (Точность: {accuracy_mlp_10:.2f})')
+
+# Многослойный персептрон с 100 нейронами
+plt.subplot(133)
+plt.scatter(X_test[:, 0], X_test[:, 1], c=y_pred_mlp_100, cmap=plt.cm.Paired)
+plt.title(f'MLP (100 нейронов) (Точность: {accuracy_mlp_100:.2f})')
+
+plt.show()

madyshev_egor_lab_1/main.py

@@ -0,0 +1,51 @@
+import random
+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.neural_network import MLPClassifier
+from sklearn.linear_model import LinearRegression
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.linear_model import Perceptron
+
+rs = random.randrange(100)
+X, y = make_moons(n_samples=200, 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)
+print("Линейная регрессия")
+linerModel = LinearRegression().fit(X_train, y_train)
+print("результат модели на учебных данных =", linerModel.score(X_train, y_train))
+print("результат модели на тестовых данных =", linerModel.score(X_Test, y_test))
+print("Многослойный персептрон с 10-ю нейронами в скрытом слое")
+mlp = MLPClassifier(hidden_layer_sizes=(10), alpha = 0.01, max_iter=2000).fit(X_train, y_train)
+print("результат модели на учебных данных =", mlp.score(X_train, y_train))
+print("результат модели на тестовых данных =", mlp.score(X_Test, y_test))
+print("Персептрон ")
+perceptron = Perceptron().fit(X_train, y_train)
+print("результат модели на учебных данных =", perceptron.score(X_train, y_train))
+print("результат модели на тестовых данных =", perceptron.score(X_Test, y_test))
+
+plt.xlabel("Свойство 1")
+plt.ylabel("Свойство 2")
+plt.title("Сгенерированные данные")
+plt.scatter(X[:, 0], X[:, 1], c = y, cmap = plt.cm.Set1)
+plt.show()
+
+h = 0.01
+x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
+y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
+xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
+
+def showPlot(name, model):
+    plt.title(name)
+    c = model.predict(np.c_[xx.ravel(), yy.ravel()])
+    c = np.where(c >= 0.5, 1, 0)
+    c = c.reshape(xx.shape)
+    plt.contourf(xx, yy, c, cmap = plt.cm.Set1, alpha=0.2)
+    plt.scatter(X[:, 0], X[:, 1], c = y, cmap = plt.cm.Set1)
+    plt.show()
+
+showPlot("Линейная регрессия", linerModel)
+showPlot("Многослойный персептрон", mlp)
+showPlot("Персептрон", perceptron)

madyshev_egor_lab_1/readme.md

@@ -0,0 +1,40 @@
+# Задание
+Используя   код   из   пункта   «Регуляризация   и   сеть   прямого распространения» из методички (стр. 228), сгенерируйте определенный тип данных и сравните  на  нем  3  модели  (по  варианту).    Постройте  графики,  отобразите качество моделей, объясните полученные результаты.
+## Задание по варианту
+Генерируемы данные: make_moons (noise=0.3, random_state=rs)  
+Модели:
+* Линейную регрессию 
+* Многослойный персептрон с 10-ю нейронами в скрытом слое (alpha = 0.01) 
+* Персептрон
+## Решение
+### Запуск программы
+Для запуска программы необходимо запустить файл main.py, содержащий код программы  
+### Используемые технологии
+Программа использует следующие библиотеки:  
+- numpy - библиотека для работы с массивами и матрицами.
+- matplotlib - библиотека для создания графиков и визуализации данных.
+- sklearn - библиотека для машинного обучения и анализа данных.
+### Что делает программа
+Программа генерирует один из 100 случайных наборов данных. Данные состоят из двух полукругов для работы с алгоритмами кластеризации и классификации  
+Показывает окно с графиком и результаты работы моделей.
+### Тесты
+тесты проводились на наборах данных с 1 по 5  
+Результаты берутся из результатов работы модели на тестовых данных  
+Набор данных - Линейная регрессия - Многослойный персептрон - Персептрон  
+1 - 0.535 - 0.875 - 0.775  
+2 - 0.454 - 0.9   - 0.85  
+3 - 0.548 - 0.9   - 0.9  
+4 - 0.58  - 0.85  - 0.825  
+5 - 0.545 - 0.862 - 0.825  
+Из результатов видно, что модель линейной регрессии показала себя хуже всего. Следом идет персептрон. И лучший результат показала модель многослойного персептрона с 10-ю нейронами в скрытом слое
+
+При увеличении объема генерируемых данных с 200 до 2000, можно заметить что результаты остались примерно на том же уровне 
+Набор данных - Линейная регрессия - Многослойный персептрон - Персептрон  
+1 - 0.565 - 0.903 - 0.78  
+2 - 0.534 - 0.919 - 0.82  
+3 - 0.541 - 0.909 - 0.742  
+4 - 0.524 - 0.856 - 0.845  
+5 - 0.568 - 0.873 - 0.802  
+Тесты с дополнительным увеличением объема данных, изменений в результатах не показали  
+Из результатов можно сделать вывод, что наиболее подходящей моделью для данного типа генерируемых данных из оттестированных моделей является Многослойный персептрон  
+Разница в результатах работы персептрона и многослойного персептрона имеется из-за того что многослойный персептрон имеет более сложную структуру, чем простой персептрон, и может обучаться более сложным функциям. Кроме того, многослойный персептрон используя несколько скрытых слоев, изучает более сложные зависимости между входными и выходными данными.

madyshev_egor_lab_2/main.py

@@ -0,0 +1,63 @@
+from sklearn.feature_selection import f_regression
+from sklearn.linear_model import LinearRegression, Lasso, LassoCV
+from sklearn.preprocessing import MinMaxScaler
+import numpy as np
+from tabulate import tabulate
+
+#генерируем исходные данные: 750 строк-наблюдений и 14 столбцов-признаков
+np.random.seed(1)
+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))
+
+#линейная модель
+lr = LinearRegression()
+lr.fit(X, Y)
+#Лассо
+lasso = LassoCV()
+lasso.fit(X, Y)
+#f_regression
+f, pval = f_regression(X, Y, center=True)
+
+def ranks_minmax(ranks):
+    ranks = np.abs(ranks)
+    minmax = MinMaxScaler()
+    ranks = minmax.fit_transform(np.array(ranks).reshape(14,1)).ravel()
+    return np.round(ranks, 2)
+
+names = ["x%s" % i for i in range(1,15)]
+lrCoef = ranks_minmax(lr.coef_)
+lassoCoef = ranks_minmax(lasso.coef_)
+fCoef = ranks_minmax(f)
+mean = []
+for i in range(len(lrCoef)):
+    mean.append(round((lrCoef[i] + lassoCoef[i] + fCoef[i]) / 3, 2))
+
+
+firstRow = np.append(['Линейная регрессия'], lrCoef)
+secondRow = np.append(['Лассо'], lassoCoef)
+thirdRow = np.append(['Линейная корреляция'], fCoef)
+fourthRow = np.append(['Среднее'], mean)
+names = np.append(['Тип'], names)
+print(tabulate([firstRow,
+                secondRow,
+                thirdRow,
+                fourthRow],
+                headers=names))
+print()
+print("Индексы максимальных значений")
+print()
+names = np.append(["Место по важности"], ["%s" % i for i in range(1,15)])
+firstRow = np.append(['Линейная регрессия'], [1] + np.argsort(lrCoef)[::-1])
+secondRow = np.append(['Лассо'], [1] + np.argsort(lassoCoef)[::-1])
+thirdRow = np.append(['Линейная корреляция'], [1] + np.argsort(fCoef)[::-1])
+fourthRow = np.append(['Среднее'], [1] + np.argsort(mean)[::-1])
+print(tabulate([firstRow,
+                secondRow,
+                thirdRow,
+                fourthRow],
+                headers=names))

madyshev_egor_lab_2/readme.md

@@ -0,0 +1,48 @@
+# Задание
+Используя код из [1] (пункт «Решение задачи ранжирования признаков», стр. 205), выполните ранжирование признаков с помощью указанных по варианту моделей. Отобразите получившиеся значения\оценки каждого признака каждым методом\моделью и среднюю оценку. Проведите анализ получившихся результатов. Какие четыре признака оказались самыми важными по среднему значению? (Названия\индексы признаков и будут  ответом на задание). 
+## Задание по варианту
+* Линейная регрессия (LinearRegression) 
+* Случайное Лассо (RandomizedLasso) : Не поддерживается текущей версией библиотеки, поэтому использовалось просто Losso
+* Линейная корреляция (f_regression)
+## Решение
+### Запуск программы
+Для запуска программы необходимо запустить файл main.py, содержащий код программы  
+### Используемые технологии
+Программа использует следующие библиотеки:  
+- numpy - библиотека для работы с массивами и матрицами.
+- matplotlib - библиотека для создания графиков и визуализации данных.
+- sklearn - библиотека для машинного обучения и анализа данных.
+- tabulate - библиотека для вывода данных в виде таблицы.
+### Что делает программа
+Программа генерирует набор из 750 строк случайных данных, по 14 свойствам. Далее с помощью трех различных моделей узнаем какие из параметров модели считают важными.
+Программа выводит по 4 самых важных параметра для каждой модели.
+### Тесты
+Тип                    x1    x2    x3    x4    x5    x6    x7    x8    x9    x10    x11    x12    x13    x14  
+-------------------  ----  ----  ----  ----  ----  ----  ----  ----  ----  -----  -----  -----  -----  -----  
+Линейная регрессия   0.27  0.69  0.11     1  0.34     0  0     0.01     0   0.05   0.32   0      0.14   0.02  
+Лассо                0.28  0.71  0        1  0.35     0  0     0        0   0.04   0.34   0      0.01   0  
+Линейная корреляция  0.26  0.43  0.01     1  0.11     0  0.02  0        0   0      0.26   0.43   0.01   0.98  
+Среднее              0.27  0.61  0.04     1  0.27     0  0.01  0        0   0.03   0.31   0.14   0.05   0.33  
+  
+Индексы максимальных значений  
+  
+Место по важности      1    2    3    4    5    6    7    8    9    10    11    12    13    14  
+-------------------  ---  ---  ---  ---  ---  ---  ---  ---  ---  ----  ----  ----  ----  ----  
+Линейная регрессия     4    2    5   11    1   13    3   10   14     8    12     9     7     6  
+Лассо                  4    2    5   11    1   10   13   14   12     9     8     7     6     3  
+Линейная корреляция    4   14   12    2   11    1    5    7   13     3    10     9     8     6  
+Среднее                4    2   14   11    5    1   12   13    3    10     7     9     8     6   
+  
+Параметры x1-x5 напрямую влияют на результат.  
+Параметры x11-x14 зависят от них.  
+Параметры x5-x10 создают шум.  
+Это значит, что оценка результата выбора признаков моделью будет основываться на возможности выделить признаки x1-x5 и x11-x14 в топе признаков, при этом не захватив остальные признаки.  
+Модель линейной регрессии смогла выделить 7 важных признаков подряд.    
+Модель лассо выделила только 5 важных признаков подряд.  
+Модель линейной корреляции выделила 7 важных признаков подряд.  
+Это значит, что ни одна из трех моделей не смогла до конца определить все 9 важных признаков, делая часть из них не важными, или назначая шумовые признаки выше.  
+Отдельно стоит отметить модель линейной регрессии, хотя она не смогла выделить 9 признаков. Её выделение семи признаков содержит весь набор признаков x1-x5. А это означает, что благодаря модели линейной регрессии порог выборки можно задать так, что будут выбраны все параметры напрямую влияющие на результат. При этом выборка не будет содержать ни одного шумового параметра x6-x10.  
+Средний результат трех моделей, делает важными все параметры из набора x1-x5, x11-x14.  
+Вывод: Модель Линейной регрессии показала себя лучше всего, позволив отобрать самые важные параметры так, что в них войдут все параметры напрямую влияющие на результат.  
+Так при пороге в >0.05 в выборку войдут параметры x1-x5, x11, x13.  
+Кроме того использование среднего результата трех моделей тоже имеет место быть, как потенциально более стабильный вариант.

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))

zavrazhnova_svetlana_lab_1/README.md

@@ -0,0 +1,31 @@
+### Задание:
+Данные: 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)

zavrazhnova_svetlana_lab_1/zavrazhnova_svetlana_lab_1.py

@@ -0,0 +1,89 @@
+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()

zavrazhnova_svetlana_lab_2/README.md

@@ -0,0 +1,30 @@
+### Задание по варианту
+Лассо (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), что указывает на их минимальную значимость или наличие практически нулевых эффектов.
+

zavrazhnova_svetlana_lab_2/zavrazhnova_svetlana_lab_2.py

@@ -0,0 +1,54 @@
+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]}')

zavrazhnova_svetlana_lab_3/README.md

@@ -0,0 +1,58 @@
+# Задание
+- Часть 1. По данным о пассажирах Титаника решите задачу классификации (с помощью дерева решений), в которой по различным характеристикам пассажиров требуется найти у выживших пассажиров два наиболее важных признака из трех рассматриваемых (по варианту).
+  Вариант: Pclass, Sex, Embarked
+- Часть 2. Решите с помощью библиотечной реализации дерева решений задачу: Запрограммировать дерево решений как минимум на 99% ваших данных для задачи: Зависимость Мошенничества (fraud_label) от возраста (Age) и пола (gender) . Проверьте работу модели на оставшемся проценте, сделайте вывод.
+
+
+### Как запустить лабораторную работу:
+1 часть ЛР запускается в файле `zavrazhnova_svetlana_lab_3_1.py` через Run, в консоли должны появится вычисления.
+
+2 часть ЛР запускается в файле `zavrazhnova_svetlana_lab_3_2.py` через Run, в консоли должны появится вычисления.
+
+### Технологии
+В библиотеке scikit-learn решающие деревья реализованы
+в классах sklearn.tree.DecisionTreeСlassifier (для классификации)
+и sklearn.tree.DecisionTreeRegressor (для регрессии).
+
+### Что делает лабораторная:
+Часть 1: 
+- Загружается выборка из файла titanic.csv с помощью пакета
+Pandas
+- Отбирается в выборку 3 признака: класс пассажира
+(Pclass), его пол (Sex) и Embarked.
+- Определяется целевая переменная (2urvived)
+- Обучается решающее дерево с параметром random_state=241
+и остальными параметрами по умолчанию (речь идет
+о параметрах конструктора DecisionTreeСlassifier)
+- Выводятся важности признаков
+
+Часть 2:
+- Загружается выборка из файла fraud_dataset.csv с помощью пакета
+Pandas
+- Отбирается в выборку 2 признака: возраст жертвы мошенничества
+(age) и его пол (gender).
+- Определяется целевая переменная (fraud_label)
+- Резделяются данные на обучающую и тестовую
+- Обучается решающее дерево классификацией DecisionTreeСlassifier и регрессией DecisionTreeRegressor
+- Выводятся важности признаков,  предсказание значений на тестовой выборке и оценка производительности модели
+
+### Пример выходных значений:
+Часть 1: Выводится список из первых 5 записей в таблице с нужными столбцами и важности признаков по каждому классу
+
+![res_lab3_1](res_lab3_1.png)
+
+Часть 2:
+
+![list_lab3_2](list_lab3_2.png)
+![res_lab3_2](res_lab3_2.png)
+
+### Вывод по 2 части ЛР:
+Исходя из этих результатов, можно сделать вывод, что для задачи предсказания мошенничества (fraud_label) на основе возраста (age) и пола (gender) лучше подходит модель дерева классификации. Она показала 100% точность на тестовой выборке, а также позволяет определить важности признаков.
+
+С другой стороны, дерево регрессии показало неопределенный R^2 score и имеет значительно большую среднеквадратичную ошибку, что говорит о том, что эта модель не подходит для данной задачи.
+
+Результат regression score = nan происходит из-за того, что при test_size=0.01 выделенная тестовая выборка содержит меньше двух образцов. Это приводит к неопределенности значения коэффициента детерминации R^2, который вычисляется в случае регрессии. Таким образом, значение score regression становится "nan".
+
+Однако, в случае классификации, где используется DecisionTreeClassifier, в test_size=0.01 попадает достаточное количество образцов для оценки производительности модели. Поэтому значение score classifier равно 1.0.
+
+`Таким образом`, для задачи классификации мошенничества на основе возраста и пола более предпочтительна модель дерева классификации.

zavrazhnova_svetlana_lab_3/fraud_dataset.csv

@@ -0,0 +1,87 @@
+transaction_id,transaction_amount,location,merchant,age,gender,fraud_label
+1,1000.00,New York,ABC Corp,35,M,0
+2,500.00,Chicago,XYZ Inc,45,F,0
+3,2000.00,Los Angeles,ABC Corp,28,M,1
+4,1500.00,San Francisco,XYZ Inc,30,F,0
+5,800.00,Chicago,ABC Corp,50,F,0
+6,3000.00,New York,XYZ Inc,42,M,1
+7,1200.00,San Francisco,ABC Corp,55,F,0
+8,900.00,Los Angeles,XYZ Inc,37,M,0
+9,2500.00,Chicago,ABC Corp,33,F,1
+10,1800.00,New York,XYZ Inc,48,M,0
+11,750.00,San Francisco,ABC Corp,29,F,0
+12,2200.00,Chicago,XYZ Inc,51,M,0
+13,900.00,New York,ABC Corp,40,F,0
+14,1600.00,Los Angeles,XYZ Inc,26,M,0
+15,3000.00,San Francisco,ABC Corp,45,F,1
+16,1200.00,Chicago,XYZ Inc,34,M,0
+17,800.00,New York,ABC Corp,47,F,0
+18,1900.00,Los Angeles,XYZ Inc,32,M,0
+19,1100.00,San Francisco,ABC Corp,52,F,0
+20,4000.00,Chicago,XYZ Inc,38,M,1
+21,900.00,New York,ABC Corp,31,F,0
+22,1700.00,Los Angeles,XYZ Inc,49,M,0
+23,1000.00,San Francisco,ABC Corp,36,F,0
+24,2300.00,Chicago,XYZ Inc,27,M,1
+25,950.00,New York,ABC Corp,41,F,0
+26,1400.00,Los Angeles,XYZ Inc,54,M,0
+27,2800.00,San Francisco,ABC Corp,39,F,1
+28,1100.00,Chicago,XYZ Inc,44,M,0
+29,750.00,New York,ABC Corp,30,F,0
+30,2000.00,Los Angeles,XYZ Inc,46,M,0
+31,1250.00,San Francisco,ABC Corp,35,F,0
+32,2100.00,Chicago,XYZ Inc,43,M,0
+33,950.00,New York,ABC Corp,56,F,0
+34,1800.00,Los Angeles,XYZ Inc,29,M,0
+35,3200.00,San Francisco,ABC Corp,48,F,1
+36,1300.00,Chicago,XYZ Inc,37,M,0
+37,900.00,New York,ABC Corp,51,F,0
+38,2000.00,Los Angeles,XYZ Inc,33,M,0
+39,1050.00,San Francisco,ABC Corp,42,F,0
+40,2400.00,Chicago,XYZ Inc,26,M,0
+41,800.00,New York,ABC Corp,45,F,0
+42,1500.00,Los Angeles,XYZ Inc,31,M,0
+43,2800.00,San Francisco,ABC Corp,50,F,1
+44,1350.00,Chicago,XYZ Inc,28,M,0
+45,920.00,New York,ABC Corp,47,F,0
+46,2000.00,Los Angeles,XYZ Inc,36,M,0
+47,1125.00,San Francisco,ABC Corp,52,F,0
+48,1900.00,Chicago,XYZ Inc,38,M,1
+49,850.00,New York,ABC Corp,32,F,0
+50,1750.00,Los Angeles,XYZ Inc,49,M,0
+51,950.00,San Francisco,ABC Corp,27,F,0
+52,2300.00,Chicago,XYZ Inc,41,M,0
+53,850.00,New York,ABC Corp,54,F,0
+54,1600.00,Los Angeles,XYZ Inc,39,M,0
+55,3000.00,San Francisco,ABC Corp,46,F,1
+56,1250.00,Chicago,XYZ Inc,35,M,0
+57,800.00,New York,ABC Corp,56,F,0
+58,2200.00,Los Angeles,XYZ Inc,29,M,0
+59,1050.00,San Francisco,ABC Corp,48,F,0
+60,4000.00,Chicago,XYZ Inc,37,M,1
+61,950.00,New York,ABC Corp,30,F,0
+62,1700.00,Los Angeles,XYZ Inc,49,M,0
+63,1000.00,San Francisco,ABC Corp,36,F,0
+64,2800.00,Chicago,XYZ Inc,27,M,1
+65,900.00,New York,ABC Corp,41,F,0
+66,1400.00,Los Angeles,XYZ Inc,54,M,0
+67,3200.00,San Francisco,ABC Corp,39,F,1
+68,1100.00,Chicago,XYZ Inc,44,M,0
+69,750.00,New York,ABC Corp,30,F,0
+70,2000.00,Los Angeles,XYZ Inc,46,M,0
+71,1250.00,San Francisco,ABC Corp,35,F,0
+72,2100.00,Chicago,XYZ Inc,43,M,0
+73,950.00,New York,ABC Corp,56,F,0
+74,1800.00,Los Angeles,XYZ Inc,29,M,0
+75,3200.00,San Francisco,ABC Corp,48,F,1
+76,1300.00,Chicago,XYZ Inc,37,M,0
+77,900.00,New York,ABC Corp,51,F,0
+78,2000.00,Los Angeles,XYZ Inc,33,M,0
+79,1050.00,San Francisco,ABC Corp,42,F,0
+80,2400.00,Chicago,XYZ Inc,26,M,0
+81,800.00,New York,ABC Corp,45,F,0
+82,1500.00,Los Angeles,XYZ Inc,31,M,0
+83,2800.00,San Francisco,ABC Corp,50,F,1
+84,1350.00,Chicago,XYZ Inc,28,M,0
+85,920.00,New York,ABC Corp,47,F,0
+86,2000.00,Los Angeles,XYZ Inc,36,M,0

zavrazhnova_svetlana_lab_3/zavrazhnova_svetlana_lab3_2.py

@@ -0,0 +1,49 @@
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeRegressor, DecisionTreeClassifier
+from sklearn.metrics import mean_squared_error
+from sklearn.metrics import accuracy_score
+
+# Загрузка данных из csv-файла
+data = pd.read_csv('fraud_dataset.csv', index_col='transaction_id')
+
+# Приведение пола к числовому виду
+data['gender'] = data['gender'].map({'M': 0, 'F': 1})
+
+# Разделение данных на признаки (X) и целевую переменную (y)
+X = data[['age', 'gender']]
+#респечатка первых 5 строк данных
+print (X.head())
+y = data['fraud_label']
+
+# Разделение данных на обучающую и тестовую выборки
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.01, random_state=42)
+
+#Решение с помощью дерева регрессии
+regression_tree = DecisionTreeRegressor()
+regression_tree.fit(X_train, y_train)
+test_score_reg = regression_tree.score(X_test, y_test)
+# Получение важности признаков
+feature_importances_reg = regression_tree.feature_importances_
+# Предсказание значений на тестовой выборке regression
+y_pred_reg = regression_tree.predict(X_test)
+# Оценка производительности модели regression
+mse = mean_squared_error(y_test, y_pred_reg)
+
+#Решение с помощью дерева классификации
+classifier_tree = DecisionTreeClassifier()
+classifier_tree.fit(X_train, y_train)
+test_score_class = classifier_tree.score(X_test, y_test)
+feature_importances_class = classifier_tree.feature_importances_
+y_pred_class = classifier_tree.predict(X_test)
+accuracy = accuracy_score(y_test, y_pred_class)
+
+print("Решением с помощью дерева регрессии:")
+print("score regression", test_score_reg)
+print("feature_importances_reg", feature_importances_reg)
+print("Mean Squared Error regression: {:.2f}".format(mse))
+print("")
+print("Решением с помощью дерева классификации:")
+print("score classifier", test_score_class)
+print("feature_importances_class", feature_importances_class)
+print("Accuracy classifier: {:.2f}%".format(accuracy * 100))

zavrazhnova_svetlana_lab_3/zavrazhnova_svetlana_lab_3_1.py

@@ -0,0 +1,21 @@
+import pandas
+from sklearn.tree import DecisionTreeClassifier
+import numpy as np
+data = pandas.read_csv('titanic.csv', index_col='Passengerid')
+
+#выгрузка непустых данных
+data=data.loc[(np.isnan(data['Pclass'])==False) & (np.isnan(data['Sex'])==False)
+&(np.isnan(data['Embarked'])==False) &
+(np.isnan(data['2urvived'])==False)]
+#отбор нужных столбцов
+corr = data[['Pclass', 'Sex', 'Embarked']]
+#респечатка первых 5 строк данных
+print (corr.head())
+#определение целевой переменной
+y = data['2urvived']
+#создание и обучение дерева решений
+clf = DecisionTreeClassifier(random_state=241)
+clf.fit(corr, y)
+#получение и распечатка важностей признаков
+importances=clf.feature_importances_
+print (importances)