diff --git a/hw1 (ERM, true risk)/hw1.py b/hw1 (ERM, true risk)/hw1.py new file mode 100755 index 0000000..e70deeb --- /dev/null +++ b/hw1 (ERM, true risk)/hw1.py @@ -0,0 +1,53 @@ +#!/usr/bin/env python +import random + +import numpy as np +from matplotlib import pyplot + + +def generate_sample(m, rect_size): + return [(random.uniform(0, rect_size), random.uniform(0, rect_size)) for _ in range(m)] + + +def true_risk(sample, rectX_size, rectQ_size): + q_points = [point for point in sample if point[0] <= rectQ_size and point[1] <= rectQ_size] + rect_area = 0 + if len(q_points) > 1: + x = list(map(lambda point: point[0], q_points)) + y = list(map(lambda point: point[1], q_points)) + rect_area = (max(x) - min(x)) * (max(y) - min(y)) + return (rectQ_size ** 2 - rect_area) / rectX_size ** 2 + + +def single_experiment(m, rectX_size, rectQ_size): + sample = generate_sample(m, rectX_size) + return true_risk(sample, rectX_size, rectQ_size) + + +rectX_size = 1.0 +rectQ_size = 0.5 ** 0.5 + +x = range(1, 500) +y = [single_experiment(m, rectX_size, rectQ_size) for m in x] +pyplot.plot(x, y) +pyplot.show() + + +def calculate_min_m(m_start, e): + m = m_start + true_risk = 1 + while true_risk > e: + trials = [single_experiment(m, rectX_size, rectQ_size) for _ in range(10)] + true_risk = np.mean(trials) + m += 1 + return m + + +e = [0.1, 0.01, 0.001] +m = [None] * len(e) +for i in range(len(e)): + m_start = 1 if i == 0 else m[i - 1] + m[i] = calculate_min_m(m_start, e[i]) + +for m_i, e_i in zip(m, e): + print('m = {} for true_risk = {}'.format(m_i, e_i)) diff --git a/hw1 (ERM, true risk)/hw1_solution.pdf b/hw1 (ERM, true risk)/hw1_solution.pdf new file mode 100644 index 0000000..fa369a1 Binary files /dev/null and b/hw1 (ERM, true risk)/hw1_solution.pdf differ diff --git a/hw1 (ERM, true risk)/hw1_task.pdf b/hw1 (ERM, true risk)/hw1_task.pdf new file mode 100644 index 0000000..260b189 Binary files /dev/null and b/hw1 (ERM, true risk)/hw1_task.pdf differ diff --git a/hw2 (linear regression, feature-engineering)/.idea/hw2.iml b/hw2 (linear regression, feature-engineering)/.idea/hw2.iml new file mode 100644 index 0000000..7d4ae81 --- /dev/null +++ b/hw2 (linear regression, feature-engineering)/.idea/hw2.iml @@ -0,0 +1,14 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/hw2 (linear regression, feature-engineering)/.idea/misc.xml b/hw2 (linear regression, feature-engineering)/.idea/misc.xml new file mode 100644 index 0000000..ae42d94 --- /dev/null +++ b/hw2 (linear regression, feature-engineering)/.idea/misc.xml @@ -0,0 +1,7 @@ + + + + + + \ No newline at end of file diff --git a/hw2 (linear regression, feature-engineering)/.idea/modules.xml b/hw2 (linear regression, feature-engineering)/.idea/modules.xml new file mode 100644 index 0000000..b3c4100 --- /dev/null +++ b/hw2 (linear regression, feature-engineering)/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/hw2 (linear regression, feature-engineering)/.idea/other.xml b/hw2 (linear regression, feature-engineering)/.idea/other.xml new file mode 100644 index 0000000..c46ee1f --- /dev/null +++ b/hw2 (linear regression, feature-engineering)/.idea/other.xml @@ -0,0 +1,8 @@ + + + + + \ No newline at end of file diff --git a/hw2 (linear regression, feature-engineering)/.idea/workspace.xml b/hw2 (linear regression, feature-engineering)/.idea/workspace.xml new file mode 100644 index 0000000..2a4a20b --- /dev/null +++ b/hw2 (linear regression, feature-engineering)/.idea/workspace.xml @@ -0,0 +1,516 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + sum_feature + vertical_symmetry_feature + sum_feature, + horizontal_symmetry_feature) + vertical_symmetry_feature, + horizontal_symmetry_feature, + INFO:root: + central + left_diagonal_symmetry_feature, + INFO:root:.* + Case: 0 vs 6 + Case: 0 vs 7 + a = transform(a) + vertical_overturn_symmetry_feature + horizontal_overturn_symmetry_feature + uppper_part_feature + vertical_center_feature + horizontal_center_feature + overturn + vertical_symme + mean + horizontal_symmetry + + + horizontal_symmetry_feature + sum_feature) + horizontal_symmetry_feature, + vertical_symmetry_feature, + horizontal_symmetry_feature) + a = np.reshape(a, (28, 28)) + + + + + + + + + true + DEFINITION_ORDER + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1541024081942 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/hw7 (GD algorithms)/.ipynb_checkpoints/hw7-checkpoint.ipynb b/hw7 (GD algorithms)/.ipynb_checkpoints/hw7-checkpoint.ipynb new file mode 100644 index 0000000..0602502 --- /dev/null +++ b/hw7 (GD algorithms)/.ipynb_checkpoints/hw7-checkpoint.ipynb @@ -0,0 +1,558 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "from collections import namedtuple, defaultdict\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import itertools" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Разделим датасет случайным образом на тренировочную и тестовую выборки. Перед сохранением в соответствующие файлы проведем стандартизацию признаков." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "classes = ('Iris-setosa', 'Iris-versicolor', 'Iris-virginica')\n", + "TRAIN_FILENAME = 'train.csv'\n", + "TEST_FILENAME = 'test.csv'\n", + "\n", + "def standardize(data):\n", + " features = data[:, :-1].astype(float)\n", + " features = (features - features.mean(axis=0)) / features.std(axis=0)\n", + " data[:, :-1] = features\n", + " return data\n", + "\n", + "\n", + "def load_data(filename):\n", + " return pd.read_csv(filename, header=None).values\n", + "\n", + "\n", + "def split_data(data_filename, train_filename, test_filename, split_ratio=0.1):\n", + " data = load_data(data_filename)\n", + " data = standardize(data)\n", + " np.random.shuffle(data)\n", + " split_index = int(len(data) * split_ratio)\n", + " pd.DataFrame(data[:split_index]).to_csv(test_filename, header=None)\n", + " pd.DataFrame(data[split_index:]).to_csv(train_filename, header=None)\n", + "\n", + "split_data('iris_data.csv', TRAIN_FILENAME, TEST_FILENAME)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "В градиентном спуске используем сигмоид как функцию для предсказания, в качестве градиента берем производную функции максимального правдоподобия. В результате работы алгоритма возвращается набор весов, вычисленных на всех итерациях." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def sigmoid(x):\n", + " return 1.0 / (1.0 + np.exp(-x))\n", + "\n", + "\n", + "def compute_gradient(x, y, w):\n", + " grad = np.dot(x.T, sigmoid(x.dot(w)) - y)\n", + " return grad if len(x.shape) == 1 else grad / len(x)\n", + "\n", + "\n", + "Parameters = namedtuple('Parameters', ['iterations', 'learning_rate', 'alpha', 'gamma', 'beta'])\n", + "ValidationResult = namedtuple('ValidationResult', ['parameters', 'accuracy'])\n", + "\n", + "\n", + "def gradient_descent(xs, ys, gd_type, parameters):\n", + " n_iter, learning_rate, alpha = parameters.iterations, parameters.learning_rate, parameters.alpha\n", + " gamma, beta = parameters.gamma, parameters.beta\n", + " eps = 1.0e-8\n", + "\n", + " ws = np.zeros((n_iter, xs.shape[1]))\n", + " avg_w, u, g, m, v = (np.zeros_like(ws[0]) for _ in range(5))\n", + "\n", + " x, y = xs, ys\n", + " for t in range(n_iter - 1):\n", + " if gd_type in ['stochastic', 'sgd+momentum', 'sgd+nesterov_momentum']:\n", + " index = random.randint(0, len(xs) - 1)\n", + " x, y = xs[index], ys[index]\n", + "\n", + " w = ws[t] + gamma * u if gd_type == 'nesterov_momentum' else ws[t]\n", + " gradient = compute_gradient(x, y, w) + alpha * w\n", + "\n", + " if gd_type in ['stochastic', 'batch']:\n", + " u = - learning_rate * gradient\n", + " elif gd_type in ['sgd+momentum', 'sgd+nesterov_momentum']:\n", + " u = gamma * u - learning_rate * gradient\n", + " elif gd_type == 'adagrad':\n", + " g += gradient ** 2\n", + " u = - learning_rate * gradient / np.sqrt(g + eps)\n", + " elif gd_type == 'rmsprop':\n", + " g = beta * g + (1 - beta) * gradient ** 2\n", + " u = - learning_rate * gradient / np.sqrt(g + eps)\n", + " elif gd_type == 'adam':\n", + " m = gamma * m + (1 - gamma) * gradient\n", + " v = beta * v + (1 - beta) * gradient ** 2\n", + " u = - learning_rate * m / np.sqrt(v + eps)\n", + " else:\n", + " raise (\"Undefined gradient descent type.\")\n", + "\n", + " ws[t + 1] = ws[t] + u\n", + " return ws" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "В качестве меры оценки качества используем точность, kfold проводим для k=10. \n", + "Вектор весов берем как среднее векторов? вычисленных на всех итерациях." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_accuracy(w, sample):\n", + " correct_count = 0\n", + " for x, y in zip(sample[:, :-1], sample[:, -1]):\n", + " y_predict = (sigmoid(x.dot(w)) >= 0.5)\n", + " correct_count += (y_predict == y)\n", + " return correct_count / len(sample)\n", + "\n", + "\n", + "def kfold(train, k, parameters, gd_type):\n", + " np.random.shuffle(train)\n", + " parts = np.array_split(train, k)\n", + " avg_accuracy = 0.0\n", + " for i in range(k):\n", + " validation_sample = parts[i]\n", + " train_sample = np.concatenate(np.delete(parts, i))\n", + "\n", + " xs, ys = train_sample[:, :-1], train_sample[:, -1]\n", + " ws = gradient_descent(xs, ys, gd_type, parameters)\n", + " avg_accuracy += compute_accuracy(ws.mean(axis=0), validation_sample)\n", + " avg_accuracy /= k\n", + " return avg_accuracy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Для удобства добавляем признак со значением 1.0, чтобы не работать с отдельным вектором b." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def transform_sample(classname, sample):\n", + " sample = np.hstack((np.ones((sample.shape[0], 1)), sample))\n", + " sample[:, -1] = (sample[:, -1] == classname)\n", + " return sample.astype(float)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "При валидации будем подбирать следующие параметры: количество итераций, скорость обучения, коэффициент регуляризации alpha, коэффициент накопления импульса gamma, коэффициент накопления квадратов градиентов beta." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def search_parameters(classname, gd_type, iterations_grid=(1000,), lr_grid=(0.01,), alpha_grid=(0.0001,),\n", + " gamma_grid=(None,), beta_grid=(None,)):\n", + " train = transform_sample(classname, load_data(TRAIN_FILENAME))\n", + " best_result = ValidationResult(Parameters(*([None] * 5)), accuracy=0.0)\n", + "\n", + " grids = [iterations_grid, lr_grid, alpha_grid, gamma_grid, beta_grid]\n", + " for param_list in itertools.product(*grids):\n", + " parameters = Parameters(*param_list)\n", + " accuracy = kfold(train, 10, parameters, gd_type)\n", + " cur_result = ValidationResult(parameters, accuracy)\n", + " if accuracy > best_result.accuracy:\n", + " best_result = cur_result\n", + " return best_result" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Создадим функции для запуска лучшего решения на тестовой выборке, и для сравнения различных методов градиентного спуска с уже подобранными параметрами. Аргументом в них передается название класса ирисов, для которого строим и тестируем модели." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def test(classname, gd_type, parameters):\n", + " train = transform_sample(classname, load_data(TRAIN_FILENAME))\n", + " test = transform_sample(classname, load_data(TEST_FILENAME))\n", + "\n", + " xs, ys = train[:, :-1], train[:, -1]\n", + " ws = gradient_descent(xs, ys, gd_type, parameters)\n", + " return compute_accuracy(ws.mean(axis=0), test)\n", + "\n", + "\n", + "def compare(classname, parameters_dict):\n", + " train = transform_sample(classname, load_data(TRAIN_FILENAME))\n", + " xs, ys = train[:, :-1], train[:, -1]\n", + "\n", + " max_iterations = max(map(lambda ps: ps.iterations, parameters_dict.values()))\n", + " for gd_type in parameters_dict:\n", + " parameters_list = list(parameters_dict[gd_type])\n", + " parameters_dict[gd_type] = Parameters(max_iterations, *(parameters_list[1:]))\n", + "\n", + " for gd_type, parameters in parameters_dict.items():\n", + " ws = gradient_descent(xs, ys, gd_type, parameters)\n", + " accuracy = [compute_accuracy(ws[:i + 1].mean(axis=0), train) for i in range(len(ws))]\n", + " plt.plot(range(parameters.iterations), accuracy)\n", + "\n", + " plt.legend(parameters_dict.keys(), loc='lower right')\n", + " plt.title(f\"Accuracy for '{classname}' model\")\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Задания 1-3. Проводим валидацию для sgd batch gradient descent, запускаем на тествой выборке лучшее решение, и строим графики зависмости точности от количества итераций, чтобы сравнить два метода." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for 'Iris-setosa' with 'stochastic': Parameters(iterations=1600, learning_rate=0.1, alpha=0.0001, gamma=None, beta=None)\n", + "Best validation accuracy for 'Iris-setosa' with 'stochastic: 0.9186813186813187\n", + "Accuracy on test sample for 'Iris-setosa' with 'stochastic: 1.0\n", + "\n", + "Best parameters for 'Iris-setosa' with 'batch': Parameters(iterations=1600, learning_rate=0.005, alpha=0.0, gamma=None, beta=None)\n", + "Best validation accuracy for 'Iris-setosa' with 'batch: 0.9543956043956046\n", + "Accuracy on test sample for 'Iris-setosa' with 'batch: 1.0\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for 'Iris-versicolor' with 'stochastic': Parameters(iterations=1600, learning_rate=0.005, alpha=0.01, gamma=None, beta=None)\n", + "Best validation accuracy for 'Iris-versicolor' with 'stochastic: 0.6978021978021978\n", + "Accuracy on test sample for 'Iris-versicolor' with 'stochastic: 0.6\n", + "\n", + "Best parameters for 'Iris-versicolor' with 'batch': Parameters(iterations=800, learning_rate=0.01, alpha=0.0, gamma=None, beta=None)\n", + "Best validation accuracy for 'Iris-versicolor' with 'batch: 0.7032967032967034\n", + "Accuracy on test sample for 'Iris-versicolor' with 'batch: 0.4666666666666667\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for 'Iris-virginica' with 'stochastic': Parameters(iterations=1600, learning_rate=0.1, alpha=0.0, gamma=None, beta=None)\n", + "Best validation accuracy for 'Iris-virginica' with 'stochastic: 0.7571428571428572\n", + "Accuracy on test sample for 'Iris-virginica' with 'stochastic: 0.7333333333333333\n", + "\n", + "Best parameters for 'Iris-virginica' with 'batch': Parameters(iterations=1600, learning_rate=0.001, alpha=0.001, gamma=None, beta=None)\n", + "Best validation accuracy for 'Iris-virginica' with 'batch: 0.8384615384615384\n", + "Accuracy on test sample for 'Iris-virginica' with 'batch: 0.7333333333333333\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "gd_types = ['stochastic', 'batch']\n", + "for classname in classes:\n", + " parameters_dict = defaultdict()\n", + " for gd_type in gd_types:\n", + " best_result = search_parameters(classname, gd_type, iterations_grid=[200, 800, 1600],\n", + " lr_grid=[0.1, 0.05, 0.01, 0.005, 0.001],\n", + " alpha_grid=[0.01, 0.001, 0.0001, 0.0])\n", + " print(f\"Best parameters for '{classname}' with '{gd_type}': {best_result.parameters}\")\n", + " print(f\"Best validation accuracy for '{classname}' with '{gd_type}: {best_result.accuracy}\")\n", + " parameters_dict[gd_type] = best_result.parameters\n", + "\n", + " accuracy = test(classname, gd_type, best_result.parameters)\n", + " print(f\"Accuracy on test sample for '{classname}' with '{gd_type}: {accuracy}\\n\")\n", + " compare(classname, parameters_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "При валидации BGD показал немного лучшие результаты качества чем у SGD на всех классах ирисов, однако на самом 'сложном' для классификации ирисе versicolor при тестировании BGD показал результаты хуже. Возможно SGD повезло разиением валидационных выборок. Сходимость у batch происходит быстрее чем у SGD.\n", + "\n", + "Преимущества SGD:\n", + "1. Требует меньших вычислительных затрат по сравнению с batch GD, особенно при больших размерах тренировочной выборки.\n", + "2. Удобно применять для online обучения, когда необходимо быстро обновлять вектор весов w.\n", + "3. При очень больших наборах данных нет необходимости хранить все объекты тренировочной выборки в памяти.\n", + "\n", + "Недостатки SGD:\n", + "1. Временами медленная сходимость.\n", + "2. Может вообще не сойтись и застрять в локальном минимуме.\n", + "\n", + "Преимущества batch gradient descent:\n", + "1. Стабильная сходимость, более быстрая по количеству итераций чем у SGD.\n", + "\n", + "Недостатки batch gradient descent:\n", + "1. Требует больших вычислительных затрат при вычислении градиента по всей выборке.\n", + "2. Проблематично применять на больших наборах данных, из-за 1. и необходимости хранить объекты тренировочной выборки в памяти.\n", + "\n", + "У обоих недостатком является фиксированная скорость обучения, которую нужно подбирать." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Задание 4. Аналогично заданиям 1-3 проводим валидацию для методов моментов и адаптивных вариантов градиентного спуска, запускаем на тестовой выборке лучшее решение, и строим графики зависмости точности от количества итераций, для сравнения всех методов. Для адаптивных методов не подбираем скорость обучения, а берем сразу достаточно большое значение 0.1 для более быстрой сходимости." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for 'Iris-setosa' with 'sgd+momentum': Parameters(iterations=1600, learning_rate=0.001, alpha=0.0001, gamma=0.999, beta=None)\n", + "Best validation accuracy for 'Iris-setosa' with 'sgd+momentum: 0.9115384615384615\n", + "Accuracy on test sample for 'Iris-setosa' with 'sgd+momentum: 1.0\n", + "\n", + "Best parameters for 'Iris-setosa' with 'sgd+nesterov_momentum': Parameters(iterations=1600, learning_rate=0.001, alpha=0.001, gamma=0.999, beta=None)\n", + "Best validation accuracy for 'Iris-setosa' with 'sgd+nesterov_momentum: 0.8879120879120878\n", + "Accuracy on test sample for 'Iris-setosa' with 'sgd+nesterov_momentum: 1.0\n", + "\n", + "Best parameters for 'Iris-setosa' with 'adagrad': Parameters(iterations=200, learning_rate=0.1, alpha=0.01, gamma=None, beta=None)\n", + "Best validation accuracy for 'Iris-setosa' with 'adagrad: 1.0\n", + "Accuracy on test sample for 'Iris-setosa' with 'adagrad: 1.0\n", + "\n", + "Best parameters for 'Iris-setosa' with 'rmsprop': Parameters(iterations=200, learning_rate=0.1, alpha=0.01, gamma=None, beta=0.9)\n", + "Best validation accuracy for 'Iris-setosa' with 'rmsprop: 1.0\n", + "Accuracy on test sample for 'Iris-setosa' with 'rmsprop: 1.0\n", + "\n", + "Best parameters for 'Iris-setosa' with 'adam': Parameters(iterations=200, learning_rate=0.1, alpha=0.01, gamma=0.9, beta=0.9)\n", + "Best validation accuracy for 'Iris-setosa' with 'adam: 1.0\n", + "Accuracy on test sample for 'Iris-setosa' with 'adam: 1.0\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for 'Iris-versicolor' with 'sgd+momentum': Parameters(iterations=1600, learning_rate=0.05, alpha=0.0001, gamma=0.9, beta=None)\n", + "Best validation accuracy for 'Iris-versicolor' with 'sgd+momentum: 0.7\n", + "Accuracy on test sample for 'Iris-versicolor' with 'sgd+momentum: 0.4666666666666667\n", + "\n", + "Best parameters for 'Iris-versicolor' with 'sgd+nesterov_momentum': Parameters(iterations=800, learning_rate=0.001, alpha=0.0001, gamma=0.999, beta=None)\n", + "Best validation accuracy for 'Iris-versicolor' with 'sgd+nesterov_momentum: 0.7027472527472528\n", + "Accuracy on test sample for 'Iris-versicolor' with 'sgd+nesterov_momentum: 0.5333333333333333\n", + "\n", + "Best parameters for 'Iris-versicolor' with 'adagrad': Parameters(iterations=1600, learning_rate=0.1, alpha=0.0001, gamma=None, beta=None)\n", + "Best validation accuracy for 'Iris-versicolor' with 'adagrad: 0.7434065934065933\n", + "Accuracy on test sample for 'Iris-versicolor' with 'adagrad: 0.6666666666666666\n", + "\n", + "Best parameters for 'Iris-versicolor' with 'rmsprop': Parameters(iterations=800, learning_rate=0.1, alpha=0.001, gamma=None, beta=0.9)\n", + "Best validation accuracy for 'Iris-versicolor' with 'rmsprop: 0.7543956043956045\n", + "Accuracy on test sample for 'Iris-versicolor' with 'rmsprop: 0.6666666666666666\n", + "\n", + "Best parameters for 'Iris-versicolor' with 'adam': Parameters(iterations=800, learning_rate=0.1, alpha=0.01, gamma=0.999, beta=0.999)\n", + "Best validation accuracy for 'Iris-versicolor' with 'adam: 0.754945054945055\n", + "Accuracy on test sample for 'Iris-versicolor' with 'adam: 0.6\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for 'Iris-virginica' with 'sgd+momentum': Parameters(iterations=1600, learning_rate=0.001, alpha=0.0, gamma=0.999, beta=None)\n", + "Best validation accuracy for 'Iris-virginica' with 'sgd+momentum: 0.8\n", + "Accuracy on test sample for 'Iris-virginica' with 'sgd+momentum: 0.8\n", + "\n", + "Best parameters for 'Iris-virginica' with 'sgd+nesterov_momentum': Parameters(iterations=1600, learning_rate=0.001, alpha=0.001, gamma=0.999, beta=None)\n", + "Best validation accuracy for 'Iris-virginica' with 'sgd+nesterov_momentum: 0.7857142857142857\n", + "Accuracy on test sample for 'Iris-virginica' with 'sgd+nesterov_momentum: 0.7333333333333333\n", + "\n", + "Best parameters for 'Iris-virginica' with 'adagrad': Parameters(iterations=800, learning_rate=0.1, alpha=0.001, gamma=None, beta=None)\n", + "Best validation accuracy for 'Iris-virginica' with 'adagrad: 0.9483516483516483\n", + "Accuracy on test sample for 'Iris-virginica' with 'adagrad: 0.8\n", + "\n", + "Best parameters for 'Iris-virginica' with 'rmsprop': Parameters(iterations=1600, learning_rate=0.1, alpha=0.0001, gamma=None, beta=0.99)\n", + "Best validation accuracy for 'Iris-virginica' with 'rmsprop: 0.9703296703296704\n", + "Accuracy on test sample for 'Iris-virginica' with 'rmsprop: 1.0\n", + "\n", + "Best parameters for 'Iris-virginica' with 'adam': Parameters(iterations=800, learning_rate=0.1, alpha=0.001, gamma=0.9, beta=0.9)\n", + "Best validation accuracy for 'Iris-virginica' with 'adam: 0.9785714285714284\n", + "Accuracy on test sample for 'Iris-virginica' with 'adam: 1.0\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "gd_types = ['sgd+momentum', 'sgd+nesterov_momentum', 'adagrad', 'rmsprop', 'adam']\n", + "for classname in classes:\n", + " parameters_dict = defaultdict()\n", + " for gd_type in gd_types:\n", + " lr_grid = [0.1] if gd_type in ['adagrad', 'rmsprop', 'adam'] else [0.1, 0.05, 0.01, 0.005, 0.001]\n", + " gamma_grid = [0.9, 0.99, 0.999] if gd_type in ['sgd+momentum', 'sgd+nesterov_momentum', 'adam'] else [None]\n", + " beta_grid = [0.9, 0.99, 0.999] if gd_type in ['rmsprop', 'adam'] else [None]\n", + "\n", + " best_result = search_parameters(classname, gd_type, iterations_grid=[200, 800, 1600],\n", + " lr_grid=lr_grid, alpha_grid=[0.01, 0.001, 0.0001, 0.0],\n", + " gamma_grid=gamma_grid, beta_grid=beta_grid)\n", + "\n", + " print(f\"Best parameters for '{classname}' with '{gd_type}': {best_result.parameters}\")\n", + " print(f\"Best validation accuracy for '{classname}' with '{gd_type}: {best_result.accuracy}\")\n", + " parameters_dict[gd_type] = best_result.parameters\n", + "\n", + " accuracy = test(classname, gd_type, best_result.parameters)\n", + " print(f\"Accuracy on test sample for '{classname}' with '{gd_type}: {accuracy}\\n\")\n", + "\n", + " compare(classname, parameters_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Наиболее быструю сходимость, а также наилучшие результаты качества как на валидационной, так и на тестовой выборках, показали adam, adagrad и rmsprop. Скорее всего, благодаря тому, что adam сочетает в себе как идею накопления движения, так и идею более слабого обновления весов для типичных признаков, т.е. преимущества методов моментов и rmsprop." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/hw7 (GD algorithms)/hw7.ipynb b/hw7 (GD algorithms)/hw7.ipynb new file mode 100644 index 0000000..0602502 --- /dev/null +++ b/hw7 (GD algorithms)/hw7.ipynb @@ -0,0 +1,558 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "from collections import namedtuple, defaultdict\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import itertools" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Разделим датасет случайным образом на тренировочную и тестовую выборки. Перед сохранением в соответствующие файлы проведем стандартизацию признаков." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "classes = ('Iris-setosa', 'Iris-versicolor', 'Iris-virginica')\n", + "TRAIN_FILENAME = 'train.csv'\n", + "TEST_FILENAME = 'test.csv'\n", + "\n", + "def standardize(data):\n", + " features = data[:, :-1].astype(float)\n", + " features = (features - features.mean(axis=0)) / features.std(axis=0)\n", + " data[:, :-1] = features\n", + " return data\n", + "\n", + "\n", + "def load_data(filename):\n", + " return pd.read_csv(filename, header=None).values\n", + "\n", + "\n", + "def split_data(data_filename, train_filename, test_filename, split_ratio=0.1):\n", + " data = load_data(data_filename)\n", + " data = standardize(data)\n", + " np.random.shuffle(data)\n", + " split_index = int(len(data) * split_ratio)\n", + " pd.DataFrame(data[:split_index]).to_csv(test_filename, header=None)\n", + " pd.DataFrame(data[split_index:]).to_csv(train_filename, header=None)\n", + "\n", + "split_data('iris_data.csv', TRAIN_FILENAME, TEST_FILENAME)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "В градиентном спуске используем сигмоид как функцию для предсказания, в качестве градиента берем производную функции максимального правдоподобия. В результате работы алгоритма возвращается набор весов, вычисленных на всех итерациях." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def sigmoid(x):\n", + " return 1.0 / (1.0 + np.exp(-x))\n", + "\n", + "\n", + "def compute_gradient(x, y, w):\n", + " grad = np.dot(x.T, sigmoid(x.dot(w)) - y)\n", + " return grad if len(x.shape) == 1 else grad / len(x)\n", + "\n", + "\n", + "Parameters = namedtuple('Parameters', ['iterations', 'learning_rate', 'alpha', 'gamma', 'beta'])\n", + "ValidationResult = namedtuple('ValidationResult', ['parameters', 'accuracy'])\n", + "\n", + "\n", + "def gradient_descent(xs, ys, gd_type, parameters):\n", + " n_iter, learning_rate, alpha = parameters.iterations, parameters.learning_rate, parameters.alpha\n", + " gamma, beta = parameters.gamma, parameters.beta\n", + " eps = 1.0e-8\n", + "\n", + " ws = np.zeros((n_iter, xs.shape[1]))\n", + " avg_w, u, g, m, v = (np.zeros_like(ws[0]) for _ in range(5))\n", + "\n", + " x, y = xs, ys\n", + " for t in range(n_iter - 1):\n", + " if gd_type in ['stochastic', 'sgd+momentum', 'sgd+nesterov_momentum']:\n", + " index = random.randint(0, len(xs) - 1)\n", + " x, y = xs[index], ys[index]\n", + "\n", + " w = ws[t] + gamma * u if gd_type == 'nesterov_momentum' else ws[t]\n", + " gradient = compute_gradient(x, y, w) + alpha * w\n", + "\n", + " if gd_type in ['stochastic', 'batch']:\n", + " u = - learning_rate * gradient\n", + " elif gd_type in ['sgd+momentum', 'sgd+nesterov_momentum']:\n", + " u = gamma * u - learning_rate * gradient\n", + " elif gd_type == 'adagrad':\n", + " g += gradient ** 2\n", + " u = - learning_rate * gradient / np.sqrt(g + eps)\n", + " elif gd_type == 'rmsprop':\n", + " g = beta * g + (1 - beta) * gradient ** 2\n", + " u = - learning_rate * gradient / np.sqrt(g + eps)\n", + " elif gd_type == 'adam':\n", + " m = gamma * m + (1 - gamma) * gradient\n", + " v = beta * v + (1 - beta) * gradient ** 2\n", + " u = - learning_rate * m / np.sqrt(v + eps)\n", + " else:\n", + " raise (\"Undefined gradient descent type.\")\n", + "\n", + " ws[t + 1] = ws[t] + u\n", + " return ws" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "В качестве меры оценки качества используем точность, kfold проводим для k=10. \n", + "Вектор весов берем как среднее векторов? вычисленных на всех итерациях." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_accuracy(w, sample):\n", + " correct_count = 0\n", + " for x, y in zip(sample[:, :-1], sample[:, -1]):\n", + " y_predict = (sigmoid(x.dot(w)) >= 0.5)\n", + " correct_count += (y_predict == y)\n", + " return correct_count / len(sample)\n", + "\n", + "\n", + "def kfold(train, k, parameters, gd_type):\n", + " np.random.shuffle(train)\n", + " parts = np.array_split(train, k)\n", + " avg_accuracy = 0.0\n", + " for i in range(k):\n", + " validation_sample = parts[i]\n", + " train_sample = np.concatenate(np.delete(parts, i))\n", + "\n", + " xs, ys = train_sample[:, :-1], train_sample[:, -1]\n", + " ws = gradient_descent(xs, ys, gd_type, parameters)\n", + " avg_accuracy += compute_accuracy(ws.mean(axis=0), validation_sample)\n", + " avg_accuracy /= k\n", + " return avg_accuracy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Для удобства добавляем признак со значением 1.0, чтобы не работать с отдельным вектором b." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def transform_sample(classname, sample):\n", + " sample = np.hstack((np.ones((sample.shape[0], 1)), sample))\n", + " sample[:, -1] = (sample[:, -1] == classname)\n", + " return sample.astype(float)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "При валидации будем подбирать следующие параметры: количество итераций, скорость обучения, коэффициент регуляризации alpha, коэффициент накопления импульса gamma, коэффициент накопления квадратов градиентов beta." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def search_parameters(classname, gd_type, iterations_grid=(1000,), lr_grid=(0.01,), alpha_grid=(0.0001,),\n", + " gamma_grid=(None,), beta_grid=(None,)):\n", + " train = transform_sample(classname, load_data(TRAIN_FILENAME))\n", + " best_result = ValidationResult(Parameters(*([None] * 5)), accuracy=0.0)\n", + "\n", + " grids = [iterations_grid, lr_grid, alpha_grid, gamma_grid, beta_grid]\n", + " for param_list in itertools.product(*grids):\n", + " parameters = Parameters(*param_list)\n", + " accuracy = kfold(train, 10, parameters, gd_type)\n", + " cur_result = ValidationResult(parameters, accuracy)\n", + " if accuracy > best_result.accuracy:\n", + " best_result = cur_result\n", + " return best_result" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Создадим функции для запуска лучшего решения на тестовой выборке, и для сравнения различных методов градиентного спуска с уже подобранными параметрами. Аргументом в них передается название класса ирисов, для которого строим и тестируем модели." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def test(classname, gd_type, parameters):\n", + " train = transform_sample(classname, load_data(TRAIN_FILENAME))\n", + " test = transform_sample(classname, load_data(TEST_FILENAME))\n", + "\n", + " xs, ys = train[:, :-1], train[:, -1]\n", + " ws = gradient_descent(xs, ys, gd_type, parameters)\n", + " return compute_accuracy(ws.mean(axis=0), test)\n", + "\n", + "\n", + "def compare(classname, parameters_dict):\n", + " train = transform_sample(classname, load_data(TRAIN_FILENAME))\n", + " xs, ys = train[:, :-1], train[:, -1]\n", + "\n", + " max_iterations = max(map(lambda ps: ps.iterations, parameters_dict.values()))\n", + " for gd_type in parameters_dict:\n", + " parameters_list = list(parameters_dict[gd_type])\n", + " parameters_dict[gd_type] = Parameters(max_iterations, *(parameters_list[1:]))\n", + "\n", + " for gd_type, parameters in parameters_dict.items():\n", + " ws = gradient_descent(xs, ys, gd_type, parameters)\n", + " accuracy = [compute_accuracy(ws[:i + 1].mean(axis=0), train) for i in range(len(ws))]\n", + " plt.plot(range(parameters.iterations), accuracy)\n", + "\n", + " plt.legend(parameters_dict.keys(), loc='lower right')\n", + " plt.title(f\"Accuracy for '{classname}' model\")\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Задания 1-3. Проводим валидацию для sgd batch gradient descent, запускаем на тествой выборке лучшее решение, и строим графики зависмости точности от количества итераций, чтобы сравнить два метода." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for 'Iris-setosa' with 'stochastic': Parameters(iterations=1600, learning_rate=0.1, alpha=0.0001, gamma=None, beta=None)\n", + "Best validation accuracy for 'Iris-setosa' with 'stochastic: 0.9186813186813187\n", + "Accuracy on test sample for 'Iris-setosa' with 'stochastic: 1.0\n", + "\n", + "Best parameters for 'Iris-setosa' with 'batch': Parameters(iterations=1600, learning_rate=0.005, alpha=0.0, gamma=None, beta=None)\n", + "Best validation accuracy for 'Iris-setosa' with 'batch: 0.9543956043956046\n", + "Accuracy on test sample for 'Iris-setosa' with 'batch: 1.0\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for 'Iris-versicolor' with 'stochastic': Parameters(iterations=1600, learning_rate=0.005, alpha=0.01, gamma=None, beta=None)\n", + "Best validation accuracy for 'Iris-versicolor' with 'stochastic: 0.6978021978021978\n", + "Accuracy on test sample for 'Iris-versicolor' with 'stochastic: 0.6\n", + "\n", + "Best parameters for 'Iris-versicolor' with 'batch': Parameters(iterations=800, learning_rate=0.01, alpha=0.0, gamma=None, beta=None)\n", + "Best validation accuracy for 'Iris-versicolor' with 'batch: 0.7032967032967034\n", + "Accuracy on test sample for 'Iris-versicolor' with 'batch: 0.4666666666666667\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for 'Iris-virginica' with 'stochastic': Parameters(iterations=1600, learning_rate=0.1, alpha=0.0, gamma=None, beta=None)\n", + "Best validation accuracy for 'Iris-virginica' with 'stochastic: 0.7571428571428572\n", + "Accuracy on test sample for 'Iris-virginica' with 'stochastic: 0.7333333333333333\n", + "\n", + "Best parameters for 'Iris-virginica' with 'batch': Parameters(iterations=1600, learning_rate=0.001, alpha=0.001, gamma=None, beta=None)\n", + "Best validation accuracy for 'Iris-virginica' with 'batch: 0.8384615384615384\n", + "Accuracy on test sample for 'Iris-virginica' with 'batch: 0.7333333333333333\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "gd_types = ['stochastic', 'batch']\n", + "for classname in classes:\n", + " parameters_dict = defaultdict()\n", + " for gd_type in gd_types:\n", + " best_result = search_parameters(classname, gd_type, iterations_grid=[200, 800, 1600],\n", + " lr_grid=[0.1, 0.05, 0.01, 0.005, 0.001],\n", + " alpha_grid=[0.01, 0.001, 0.0001, 0.0])\n", + " print(f\"Best parameters for '{classname}' with '{gd_type}': {best_result.parameters}\")\n", + " print(f\"Best validation accuracy for '{classname}' with '{gd_type}: {best_result.accuracy}\")\n", + " parameters_dict[gd_type] = best_result.parameters\n", + "\n", + " accuracy = test(classname, gd_type, best_result.parameters)\n", + " print(f\"Accuracy on test sample for '{classname}' with '{gd_type}: {accuracy}\\n\")\n", + " compare(classname, parameters_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "При валидации BGD показал немного лучшие результаты качества чем у SGD на всех классах ирисов, однако на самом 'сложном' для классификации ирисе versicolor при тестировании BGD показал результаты хуже. Возможно SGD повезло разиением валидационных выборок. Сходимость у batch происходит быстрее чем у SGD.\n", + "\n", + "Преимущества SGD:\n", + "1. Требует меньших вычислительных затрат по сравнению с batch GD, особенно при больших размерах тренировочной выборки.\n", + "2. Удобно применять для online обучения, когда необходимо быстро обновлять вектор весов w.\n", + "3. При очень больших наборах данных нет необходимости хранить все объекты тренировочной выборки в памяти.\n", + "\n", + "Недостатки SGD:\n", + "1. Временами медленная сходимость.\n", + "2. Может вообще не сойтись и застрять в локальном минимуме.\n", + "\n", + "Преимущества batch gradient descent:\n", + "1. Стабильная сходимость, более быстрая по количеству итераций чем у SGD.\n", + "\n", + "Недостатки batch gradient descent:\n", + "1. Требует больших вычислительных затрат при вычислении градиента по всей выборке.\n", + "2. Проблематично применять на больших наборах данных, из-за 1. и необходимости хранить объекты тренировочной выборки в памяти.\n", + "\n", + "У обоих недостатком является фиксированная скорость обучения, которую нужно подбирать." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Задание 4. Аналогично заданиям 1-3 проводим валидацию для методов моментов и адаптивных вариантов градиентного спуска, запускаем на тестовой выборке лучшее решение, и строим графики зависмости точности от количества итераций, для сравнения всех методов. Для адаптивных методов не подбираем скорость обучения, а берем сразу достаточно большое значение 0.1 для более быстрой сходимости." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for 'Iris-setosa' with 'sgd+momentum': Parameters(iterations=1600, learning_rate=0.001, alpha=0.0001, gamma=0.999, beta=None)\n", + "Best validation accuracy for 'Iris-setosa' with 'sgd+momentum: 0.9115384615384615\n", + "Accuracy on test sample for 'Iris-setosa' with 'sgd+momentum: 1.0\n", + "\n", + "Best parameters for 'Iris-setosa' with 'sgd+nesterov_momentum': Parameters(iterations=1600, learning_rate=0.001, alpha=0.001, gamma=0.999, beta=None)\n", + "Best validation accuracy for 'Iris-setosa' with 'sgd+nesterov_momentum: 0.8879120879120878\n", + "Accuracy on test sample for 'Iris-setosa' with 'sgd+nesterov_momentum: 1.0\n", + "\n", + "Best parameters for 'Iris-setosa' with 'adagrad': Parameters(iterations=200, learning_rate=0.1, alpha=0.01, gamma=None, beta=None)\n", + "Best validation accuracy for 'Iris-setosa' with 'adagrad: 1.0\n", + "Accuracy on test sample for 'Iris-setosa' with 'adagrad: 1.0\n", + "\n", + "Best parameters for 'Iris-setosa' with 'rmsprop': Parameters(iterations=200, learning_rate=0.1, alpha=0.01, gamma=None, beta=0.9)\n", + "Best validation accuracy for 'Iris-setosa' with 'rmsprop: 1.0\n", + "Accuracy on test sample for 'Iris-setosa' with 'rmsprop: 1.0\n", + "\n", + "Best parameters for 'Iris-setosa' with 'adam': Parameters(iterations=200, learning_rate=0.1, alpha=0.01, gamma=0.9, beta=0.9)\n", + "Best validation accuracy for 'Iris-setosa' with 'adam: 1.0\n", + "Accuracy on test sample for 'Iris-setosa' with 'adam: 1.0\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for 'Iris-versicolor' with 'sgd+momentum': Parameters(iterations=1600, learning_rate=0.05, alpha=0.0001, gamma=0.9, beta=None)\n", + "Best validation accuracy for 'Iris-versicolor' with 'sgd+momentum: 0.7\n", + "Accuracy on test sample for 'Iris-versicolor' with 'sgd+momentum: 0.4666666666666667\n", + "\n", + "Best parameters for 'Iris-versicolor' with 'sgd+nesterov_momentum': Parameters(iterations=800, learning_rate=0.001, alpha=0.0001, gamma=0.999, beta=None)\n", + "Best validation accuracy for 'Iris-versicolor' with 'sgd+nesterov_momentum: 0.7027472527472528\n", + "Accuracy on test sample for 'Iris-versicolor' with 'sgd+nesterov_momentum: 0.5333333333333333\n", + "\n", + "Best parameters for 'Iris-versicolor' with 'adagrad': Parameters(iterations=1600, learning_rate=0.1, alpha=0.0001, gamma=None, beta=None)\n", + "Best validation accuracy for 'Iris-versicolor' with 'adagrad: 0.7434065934065933\n", + "Accuracy on test sample for 'Iris-versicolor' with 'adagrad: 0.6666666666666666\n", + "\n", + "Best parameters for 'Iris-versicolor' with 'rmsprop': Parameters(iterations=800, learning_rate=0.1, alpha=0.001, gamma=None, beta=0.9)\n", + "Best validation accuracy for 'Iris-versicolor' with 'rmsprop: 0.7543956043956045\n", + "Accuracy on test sample for 'Iris-versicolor' with 'rmsprop: 0.6666666666666666\n", + "\n", + "Best parameters for 'Iris-versicolor' with 'adam': Parameters(iterations=800, learning_rate=0.1, alpha=0.01, gamma=0.999, beta=0.999)\n", + "Best validation accuracy for 'Iris-versicolor' with 'adam: 0.754945054945055\n", + "Accuracy on test sample for 'Iris-versicolor' with 'adam: 0.6\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for 'Iris-virginica' with 'sgd+momentum': Parameters(iterations=1600, learning_rate=0.001, alpha=0.0, gamma=0.999, beta=None)\n", + "Best validation accuracy for 'Iris-virginica' with 'sgd+momentum: 0.8\n", + "Accuracy on test sample for 'Iris-virginica' with 'sgd+momentum: 0.8\n", + "\n", + "Best parameters for 'Iris-virginica' with 'sgd+nesterov_momentum': Parameters(iterations=1600, learning_rate=0.001, alpha=0.001, gamma=0.999, beta=None)\n", + "Best validation accuracy for 'Iris-virginica' with 'sgd+nesterov_momentum: 0.7857142857142857\n", + "Accuracy on test sample for 'Iris-virginica' with 'sgd+nesterov_momentum: 0.7333333333333333\n", + "\n", + "Best parameters for 'Iris-virginica' with 'adagrad': Parameters(iterations=800, learning_rate=0.1, alpha=0.001, gamma=None, beta=None)\n", + "Best validation accuracy for 'Iris-virginica' with 'adagrad: 0.9483516483516483\n", + "Accuracy on test sample for 'Iris-virginica' with 'adagrad: 0.8\n", + "\n", + "Best parameters for 'Iris-virginica' with 'rmsprop': Parameters(iterations=1600, learning_rate=0.1, alpha=0.0001, gamma=None, beta=0.99)\n", + "Best validation accuracy for 'Iris-virginica' with 'rmsprop: 0.9703296703296704\n", + "Accuracy on test sample for 'Iris-virginica' with 'rmsprop: 1.0\n", + "\n", + "Best parameters for 'Iris-virginica' with 'adam': Parameters(iterations=800, learning_rate=0.1, alpha=0.001, gamma=0.9, beta=0.9)\n", + "Best validation accuracy for 'Iris-virginica' with 'adam: 0.9785714285714284\n", + "Accuracy on test sample for 'Iris-virginica' with 'adam: 1.0\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "gd_types = ['sgd+momentum', 'sgd+nesterov_momentum', 'adagrad', 'rmsprop', 'adam']\n", + "for classname in classes:\n", + " parameters_dict = defaultdict()\n", + " for gd_type in gd_types:\n", + " lr_grid = [0.1] if gd_type in ['adagrad', 'rmsprop', 'adam'] else [0.1, 0.05, 0.01, 0.005, 0.001]\n", + " gamma_grid = [0.9, 0.99, 0.999] if gd_type in ['sgd+momentum', 'sgd+nesterov_momentum', 'adam'] else [None]\n", + " beta_grid = [0.9, 0.99, 0.999] if gd_type in ['rmsprop', 'adam'] else [None]\n", + "\n", + " best_result = search_parameters(classname, gd_type, iterations_grid=[200, 800, 1600],\n", + " lr_grid=lr_grid, alpha_grid=[0.01, 0.001, 0.0001, 0.0],\n", + " gamma_grid=gamma_grid, beta_grid=beta_grid)\n", + "\n", + " print(f\"Best parameters for '{classname}' with '{gd_type}': {best_result.parameters}\")\n", + " print(f\"Best validation accuracy for '{classname}' with '{gd_type}: {best_result.accuracy}\")\n", + " parameters_dict[gd_type] = best_result.parameters\n", + "\n", + " accuracy = test(classname, gd_type, best_result.parameters)\n", + " print(f\"Accuracy on test sample for '{classname}' with '{gd_type}: {accuracy}\\n\")\n", + "\n", + " compare(classname, parameters_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Наиболее быструю сходимость, а также наилучшие результаты качества как на валидационной, так и на тестовой выборках, показали adam, adagrad и rmsprop. Скорее всего, благодаря тому, что adam сочетает в себе как идею накопления движения, так и идею более слабого обновления весов для типичных признаков, т.е. преимущества методов моментов и rmsprop." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/hw7 (GD algorithms)/hw7.py b/hw7 (GD algorithms)/hw7.py new file mode 100644 index 0000000..14ed932 --- /dev/null +++ b/hw7 (GD algorithms)/hw7.py @@ -0,0 +1,207 @@ +#!/usr/bin/env python3 +import random +from collections import namedtuple, defaultdict + +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +import itertools + +classes = ('Iris-setosa', 'Iris-versicolor', 'Iris-virginica') +TRAIN_FILENAME = 'train.csv' +TEST_FILENAME = 'test.csv' + + +def standardize(data): + features = data[:, :-1].astype(float) + features = (features - features.mean(axis=0)) / features.std(axis=0) + data[:, :-1] = features + return data + + +def load_data(filename): + return pd.read_csv(filename, header=None).values + + +def split_data(data_filename, train_filename, test_filename, split_ratio=0.1): + data = load_data(data_filename) + data = standardize(data) + np.random.shuffle(data) + split_index = int(len(data) * split_ratio) + pd.DataFrame(data[:split_index]).to_csv(test_filename, header=None) + pd.DataFrame(data[split_index:]).to_csv(train_filename, header=None) + + +def sigmoid(x): + return 1.0 / (1.0 + np.exp(-x)) + + +def compute_gradient(x, y, w): + grad = np.dot(x.T, sigmoid(x.dot(w)) - y) + return grad if len(x.shape) == 1 else grad / len(x) + + +Parameters = namedtuple('Parameters', ['iterations', 'learning_rate', 'alpha', 'gamma', 'beta']) +ValidationResult = namedtuple('ValidationResult', ['parameters', 'accuracy']) + + +def gradient_descent(xs, ys, gd_type, parameters): + n_iter, learning_rate, alpha = parameters.iterations, parameters.learning_rate, parameters.alpha + gamma, beta = parameters.gamma, parameters.beta + eps = 1.0e-8 + + ws = np.zeros((n_iter, xs.shape[1])) + avg_w, u, g, m, v = (np.zeros_like(ws[0]) for _ in range(5)) + + x, y = xs, ys + for t in range(n_iter - 1): + if gd_type in ['stochastic', 'sgd+momentum', 'sgd+nesterov_momentum']: + index = random.randint(0, len(xs) - 1) + x, y = xs[index], ys[index] + + w = ws[t] + gamma * u if gd_type == 'nesterov_momentum' else ws[t] + gradient = compute_gradient(x, y, w) + alpha * w + + if gd_type in ['stochastic', 'batch']: + u = - learning_rate * gradient + elif gd_type in ['sgd+momentum', 'sgd+nesterov_momentum']: + u = gamma * u - learning_rate * gradient + elif gd_type == 'adagrad': + g += gradient ** 2 + u = - learning_rate * gradient / np.sqrt(g + eps) + elif gd_type == 'rmsprop': + g = beta * g + (1 - beta) * gradient ** 2 + u = - learning_rate * gradient / np.sqrt(g + eps) + elif gd_type == 'adam': + m = gamma * m + (1 - gamma) * gradient + v = beta * v + (1 - beta) * gradient ** 2 + u = - learning_rate * m / np.sqrt(v + eps) + else: + raise ("Undefined gradient descent type.") + + ws[t + 1] = ws[t] + u + return ws + + +def compute_accuracy(w, sample): + correct_count = 0 + for x, y in zip(sample[:, :-1], sample[:, -1]): + y_predict = (sigmoid(x.dot(w)) >= 0.5) + correct_count += (y_predict == y) + return correct_count / len(sample) + + +def kfold(train, k, parameters, gd_type): + np.random.shuffle(train) + parts = np.array_split(train, k) + avg_accuracy = 0.0 + for i in range(k): + validation_sample = parts[i] + train_sample = np.concatenate(np.delete(parts, i)) + + xs, ys = train_sample[:, :-1], train_sample[:, -1] + ws = gradient_descent(xs, ys, gd_type, parameters) + avg_accuracy += compute_accuracy(ws.mean(axis=0), validation_sample) + avg_accuracy /= k + return avg_accuracy + + +def transform_sample(classname, sample): + bias = np.ones((sample.shape[0], 1)) + sample = np.hstack((bias, sample)) + sample[:, -1] = (sample[:, -1] == classname) + return sample.astype(float) + + +def search_parameters(classname, gd_type, iterations_grid=(1000,), lr_grid=(0.01,), alpha_grid=(0.0001,), + gamma_grid=(None,), beta_grid=(None,)): + train = transform_sample(classname, load_data(TRAIN_FILENAME)) + best_result = ValidationResult(Parameters(*([None] * 5)), accuracy=0.0) + + grids = [iterations_grid, lr_grid, alpha_grid, gamma_grid, beta_grid] + for param_list in itertools.product(*grids): + parameters = Parameters(*param_list) + accuracy = kfold(train, 10, parameters, gd_type) + cur_result = ValidationResult(parameters, accuracy) + if accuracy > best_result.accuracy: + best_result = cur_result + return best_result + + +def test(classname, gd_type, parameters): + train = transform_sample(classname, load_data(TRAIN_FILENAME)) + test = transform_sample(classname, load_data(TEST_FILENAME)) + + xs, ys = train[:, :-1], train[:, -1] + ws = gradient_descent(xs, ys, gd_type, parameters) + return compute_accuracy(ws.mean(axis=0), test) + + +def compare(classname, parameters_dict): + train = transform_sample(classname, load_data(TRAIN_FILENAME)) + xs, ys = train[:, :-1], train[:, -1] + + max_iterations = max(map(lambda ps: ps.iterations, parameters_dict.values())) + for gd_type in parameters_dict: + parameters_list = list(parameters_dict[gd_type]) + parameters_dict[gd_type] = Parameters(max_iterations, *(parameters_list[1:])) + + for gd_type, parameters in parameters_dict.items(): + ws = gradient_descent(xs, ys, gd_type, parameters) + accuracy = [compute_accuracy(ws[:i + 1].mean(axis=0), train) for i in range(len(ws))] + plt.plot(range(parameters.iterations), accuracy) + + plt.legend(parameters_dict.keys(), loc='lower right') + plt.title(f"Accuracy for '{classname}' model") + plt.show() + + +def compare_base_methods(): + gd_types = ['stochastic', 'batch'] + for classname in classes: + parameters_dict = defaultdict() + for gd_type in gd_types: + best_result = search_parameters(classname, gd_type, iterations_grid=[200, 800, 1600], + lr_grid=[0.1, 0.05, 0.01, 0.005, 0.001], + alpha_grid=[0.01, 0.001, 0.0001, 0.0]) + print(f"Best parameters for '{classname}' with '{gd_type}': {best_result.parameters}") + print(f"Best validation accuracy for '{classname}' with '{gd_type}: {best_result.accuracy}") + parameters_dict[gd_type] = best_result.parameters + + accuracy = test(classname, gd_type, best_result.parameters) + print(f"Accuracy on test sample for '{classname}' with '{gd_type}: {accuracy}\n") + + compare(classname, parameters_dict) + + +def compare_adaptive_methods(): + gd_types = ['sgd+momentum', 'sgd+nesterov_momentum', 'adagrad', 'rmsprop', 'adam'] + for classname in classes: + parameters_dict = defaultdict() + for gd_type in gd_types: + lr_grid = [0.1] if gd_type in ['adagrad', 'rmsprop', 'adam'] else [0.1, 0.05, 0.01, 0.005, 0.001] + gamma_grid = [0.9, 0.98, 0.999] if gd_type in ['sgd+momentum', 'sgd+nesterov_momentum', 'adam'] else [None] + beta_grid = [0.9, 0.98, 0.999] if gd_type in ['rmsprop', 'adam'] else [None] + + best_result = search_parameters(classname, gd_type, iterations_grid=[200, 800, 1600], + lr_grid=lr_grid, alpha_grid=[0.01, 0.001, 0.0001, 0.0], + gamma_grid=gamma_grid, beta_grid=beta_grid) + + print(f"Best parameters for '{classname}' with '{gd_type}': {best_result.parameters}") + print(f"Best validation accuracy for '{classname}' with '{gd_type}: {best_result.accuracy}") + parameters_dict[gd_type] = best_result.parameters + + accuracy = test(classname, gd_type, best_result.parameters) + print(f"Accuracy on test sample for '{classname}' with '{gd_type}: {accuracy}\n") + + compare(classname, parameters_dict) + + +def main(): + split_data('iris_data.csv', TRAIN_FILENAME, TEST_FILENAME) + compare_base_methods() + compare_adaptive_methods() + + +if __name__ == "__main__": + main() diff --git a/hw7 (GD algorithms)/hw7_task.pdf b/hw7 (GD algorithms)/hw7_task.pdf new file mode 100644 index 0000000..c427403 Binary files /dev/null and b/hw7 (GD algorithms)/hw7_task.pdf differ diff --git a/hw7 (GD algorithms)/iris_data.csv b/hw7 (GD algorithms)/iris_data.csv new file mode 100644 index 0000000..d4ee8db --- /dev/null +++ b/hw7 (GD algorithms)/iris_data.csv @@ -0,0 +1,151 @@ +5.1,3.5,1.4,0.2,Iris-setosa +4.9,3.0,1.4,0.2,Iris-setosa +4.7,3.2,1.3,0.2,Iris-setosa +4.6,3.1,1.5,0.2,Iris-setosa +5.0,3.6,1.4,0.2,Iris-setosa +5.4,3.9,1.7,0.4,Iris-setosa +4.6,3.4,1.4,0.3,Iris-setosa +5.0,3.4,1.5,0.2,Iris-setosa +4.4,2.9,1.4,0.2,Iris-setosa +4.9,3.1,1.5,0.1,Iris-setosa +5.4,3.7,1.5,0.2,Iris-setosa +4.8,3.4,1.6,0.2,Iris-setosa +4.8,3.0,1.4,0.1,Iris-setosa +4.3,3.0,1.1,0.1,Iris-setosa +5.8,4.0,1.2,0.2,Iris-setosa +5.7,4.4,1.5,0.4,Iris-setosa +5.4,3.9,1.3,0.4,Iris-setosa +5.1,3.5,1.4,0.3,Iris-setosa +5.7,3.8,1.7,0.3,Iris-setosa +5.1,3.8,1.5,0.3,Iris-setosa +5.4,3.4,1.7,0.2,Iris-setosa +5.1,3.7,1.5,0.4,Iris-setosa +4.6,3.6,1.0,0.2,Iris-setosa +5.1,3.3,1.7,0.5,Iris-setosa +4.8,3.4,1.9,0.2,Iris-setosa +5.0,3.0,1.6,0.2,Iris-setosa +5.0,3.4,1.6,0.4,Iris-setosa +5.2,3.5,1.5,0.2,Iris-setosa +5.2,3.4,1.4,0.2,Iris-setosa +4.7,3.2,1.6,0.2,Iris-setosa +4.8,3.1,1.6,0.2,Iris-setosa +5.4,3.4,1.5,0.4,Iris-setosa +5.2,4.1,1.5,0.1,Iris-setosa +5.5,4.2,1.4,0.2,Iris-setosa +4.9,3.1,1.5,0.2,Iris-setosa +5.0,3.2,1.2,0.2,Iris-setosa +5.5,3.5,1.3,0.2,Iris-setosa +4.9,3.6,1.4,0.1,Iris-setosa +4.4,3.0,1.3,0.2,Iris-setosa +5.1,3.4,1.5,0.2,Iris-setosa +5.0,3.5,1.3,0.3,Iris-setosa +4.5,2.3,1.3,0.3,Iris-setosa +4.4,3.2,1.3,0.2,Iris-setosa +5.0,3.5,1.6,0.6,Iris-setosa +5.1,3.8,1.9,0.4,Iris-setosa +4.8,3.0,1.4,0.3,Iris-setosa +5.1,3.8,1.6,0.2,Iris-setosa +4.6,3.2,1.4,0.2,Iris-setosa +5.3,3.7,1.5,0.2,Iris-setosa +5.0,3.3,1.4,0.2,Iris-setosa +7.0,3.2,4.7,1.4,Iris-versicolor +6.4,3.2,4.5,1.5,Iris-versicolor +6.9,3.1,4.9,1.5,Iris-versicolor +5.5,2.3,4.0,1.3,Iris-versicolor +6.5,2.8,4.6,1.5,Iris-versicolor +5.7,2.8,4.5,1.3,Iris-versicolor +6.3,3.3,4.7,1.6,Iris-versicolor +4.9,2.4,3.3,1.0,Iris-versicolor +6.6,2.9,4.6,1.3,Iris-versicolor +5.2,2.7,3.9,1.4,Iris-versicolor +5.0,2.0,3.5,1.0,Iris-versicolor +5.9,3.0,4.2,1.5,Iris-versicolor +6.0,2.2,4.0,1.0,Iris-versicolor +6.1,2.9,4.7,1.4,Iris-versicolor +5.6,2.9,3.6,1.3,Iris-versicolor +6.7,3.1,4.4,1.4,Iris-versicolor +5.6,3.0,4.5,1.5,Iris-versicolor +5.8,2.7,4.1,1.0,Iris-versicolor +6.2,2.2,4.5,1.5,Iris-versicolor +5.6,2.5,3.9,1.1,Iris-versicolor +5.9,3.2,4.8,1.8,Iris-versicolor +6.1,2.8,4.0,1.3,Iris-versicolor +6.3,2.5,4.9,1.5,Iris-versicolor +6.1,2.8,4.7,1.2,Iris-versicolor +6.4,2.9,4.3,1.3,Iris-versicolor +6.6,3.0,4.4,1.4,Iris-versicolor +6.8,2.8,4.8,1.4,Iris-versicolor +6.7,3.0,5.0,1.7,Iris-versicolor +6.0,2.9,4.5,1.5,Iris-versicolor +5.7,2.6,3.5,1.0,Iris-versicolor +5.5,2.4,3.8,1.1,Iris-versicolor +5.5,2.4,3.7,1.0,Iris-versicolor +5.8,2.7,3.9,1.2,Iris-versicolor +6.0,2.7,5.1,1.6,Iris-versicolor +5.4,3.0,4.5,1.5,Iris-versicolor +6.0,3.4,4.5,1.6,Iris-versicolor +6.7,3.1,4.7,1.5,Iris-versicolor +6.3,2.3,4.4,1.3,Iris-versicolor +5.6,3.0,4.1,1.3,Iris-versicolor +5.5,2.5,4.0,1.3,Iris-versicolor +5.5,2.6,4.4,1.2,Iris-versicolor +6.1,3.0,4.6,1.4,Iris-versicolor +5.8,2.6,4.0,1.2,Iris-versicolor +5.0,2.3,3.3,1.0,Iris-versicolor +5.6,2.7,4.2,1.3,Iris-versicolor +5.7,3.0,4.2,1.2,Iris-versicolor +5.7,2.9,4.2,1.3,Iris-versicolor +6.2,2.9,4.3,1.3,Iris-versicolor +5.1,2.5,3.0,1.1,Iris-versicolor +5.7,2.8,4.1,1.3,Iris-versicolor +6.3,3.3,6.0,2.5,Iris-virginica +5.8,2.7,5.1,1.9,Iris-virginica +7.1,3.0,5.9,2.1,Iris-virginica +6.3,2.9,5.6,1.8,Iris-virginica +6.5,3.0,5.8,2.2,Iris-virginica +7.6,3.0,6.6,2.1,Iris-virginica +4.9,2.5,4.5,1.7,Iris-virginica +7.3,2.9,6.3,1.8,Iris-virginica +6.7,2.5,5.8,1.8,Iris-virginica +7.2,3.6,6.1,2.5,Iris-virginica +6.5,3.2,5.1,2.0,Iris-virginica +6.4,2.7,5.3,1.9,Iris-virginica +6.8,3.0,5.5,2.1,Iris-virginica +5.7,2.5,5.0,2.0,Iris-virginica +5.8,2.8,5.1,2.4,Iris-virginica +6.4,3.2,5.3,2.3,Iris-virginica +6.5,3.0,5.5,1.8,Iris-virginica +7.7,3.8,6.7,2.2,Iris-virginica +7.7,2.6,6.9,2.3,Iris-virginica +6.0,2.2,5.0,1.5,Iris-virginica +6.9,3.2,5.7,2.3,Iris-virginica +5.6,2.8,4.9,2.0,Iris-virginica +7.7,2.8,6.7,2.0,Iris-virginica +6.3,2.7,4.9,1.8,Iris-virginica +6.7,3.3,5.7,2.1,Iris-virginica +7.2,3.2,6.0,1.8,Iris-virginica +6.2,2.8,4.8,1.8,Iris-virginica +6.1,3.0,4.9,1.8,Iris-virginica +6.4,2.8,5.6,2.1,Iris-virginica +7.2,3.0,5.8,1.6,Iris-virginica +7.4,2.8,6.1,1.9,Iris-virginica +7.9,3.8,6.4,2.0,Iris-virginica +6.4,2.8,5.6,2.2,Iris-virginica +6.3,2.8,5.1,1.5,Iris-virginica +6.1,2.6,5.6,1.4,Iris-virginica +7.7,3.0,6.1,2.3,Iris-virginica +6.3,3.4,5.6,2.4,Iris-virginica +6.4,3.1,5.5,1.8,Iris-virginica +6.0,3.0,4.8,1.8,Iris-virginica +6.9,3.1,5.4,2.1,Iris-virginica +6.7,3.1,5.6,2.4,Iris-virginica +6.9,3.1,5.1,2.3,Iris-virginica +5.8,2.7,5.1,1.9,Iris-virginica +6.8,3.2,5.9,2.3,Iris-virginica +6.7,3.3,5.7,2.5,Iris-virginica +6.7,3.0,5.2,2.3,Iris-virginica +6.3,2.5,5.0,1.9,Iris-virginica +6.5,3.0,5.2,2.0,Iris-virginica +6.2,3.4,5.4,2.3,Iris-virginica +5.9,3.0,5.1,1.8,Iris-virginica + diff --git a/hw8 (SVM)/.idea/encodings.xml b/hw8 (SVM)/.idea/encodings.xml new file mode 100644 index 0000000..15a15b2 --- /dev/null +++ b/hw8 (SVM)/.idea/encodings.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/hw8 (SVM)/.idea/hw8.iml b/hw8 (SVM)/.idea/hw8.iml new file mode 100644 index 0000000..2852213 --- /dev/null +++ b/hw8 (SVM)/.idea/hw8.iml @@ -0,0 +1,11 @@ + + + + + + + + + + \ No newline at end of file diff --git a/hw8 (SVM)/.idea/misc.xml b/hw8 (SVM)/.idea/misc.xml new file mode 100644 index 0000000..84fe515 --- /dev/null +++ b/hw8 (SVM)/.idea/misc.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/hw8 (SVM)/.idea/modules.xml b/hw8 (SVM)/.idea/modules.xml new file mode 100644 index 0000000..1a5d9f1 --- /dev/null +++ b/hw8 (SVM)/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/hw8 (SVM)/.idea/other.xml b/hw8 (SVM)/.idea/other.xml new file mode 100644 index 0000000..a708ec7 --- /dev/null +++ b/hw8 (SVM)/.idea/other.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/hw8 (SVM)/.idea/workspace.xml b/hw8 (SVM)/.idea/workspace.xml new file mode 100644 index 0000000..1ea95e7 --- /dev/null +++ b/hw8 (SVM)/.idea/workspace.xml @@ -0,0 +1,528 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + argv + precomputed + scale_param = csr_find_scale_param(x, lower=0) + scale + -v + itertools + fast + params_str.format(degree, cost) + predict + build_options + os. + spam_tmp/ + svm_train + gen_svm + abel = libsvm.svm_predict(m, + gen_svm_nodearray + np.std + kfold + build + csr_scale + f" + svm-scale + + + build_options + build_options(degree, cost) + + + + + + + + + + + + + + + + + + + + + +