gradient_descent.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Лабораторная работа №1\n",
    "## Градиентный спуск\n",
    "Трутнев Алексей Игоревич вариант №5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "from dataclasses import dataclass, field\n",
    "from collections import defaultdict\n",
    "from typing import Dict, List\n",
    "\n",
    "import numpy as np\n",
    "from numpy.typing import NDArray\n",
    "from typing import Callable\n",
    "from matplotlib import pyplot as plt\n",
    "import pickle\n",
    "\n",
    "import cvxpy as cp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "results_dump_file = 'results_dump_file.pkl'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Задача оптимизации\n",
    "\n",
    "$\\min\\{ (x-\\mu_0)^\\top A (x-\\mu_0) : ||x||_2^2 \\leq 1 \\}$, где\n",
    "* $x \\in \\mathbb{R}^n$, $A$ - симметричная, положительно определенная матрица\n",
    "* $\\mu_0 = (1,1,\\dots,1)^\\top \\in \\mathbb{R}^n$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "def function(x: NDArray, A: NDArray, mu: NDArray) -> float:\n",
    "    return (x - mu).T @ A @ (x - mu)\n",
    "\n",
    "\n",
    "def limitation(x: NDArray) -> float:\n",
    "    return np.sum(np.power(x, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_symmetric(A: NDArray) -> bool:\n",
    "    return (A==A.T).all()\n",
    "\n",
    "\n",
    "def check_positive_definition(A: NDArray) -> bool:\n",
    "    n = A.shape[0]\n",
    "    test_x = np.random.random(n)\n",
    "    return (test_x.T @ A @ test_x) > 0\n",
    "\n",
    "\n",
    "def get_symmetric_matrix(n: int) -> NDArray:\n",
    "    A = np.random.rand(n, n)\n",
    "    matrix = A @ A.T\n",
    "    assert check_symmetric(matrix) and check_positive_definition(matrix)\n",
    "    return matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ограничение\n",
    "$c(x) = ||x||_2^2 = \\sum_{i=1}^{n} x_i^2 \\leq 1$, где $x = (x_1, x_2, \\dots, x_n)^\\top \\in \\mathbb{R}^n$\n",
    "\n",
    "Градиент имеет вид: $\\nabla c(x) = (2x_1, 2x_2, \\dots, 2x_n)^\\top = 2x \\in \\mathbb{R}^n$\n",
    "\n",
    "\n",
    "### Функция\n",
    "$f(x) = (x-\\mu_0)^\\top A (x-\\mu_0)$\n",
    "\n",
    "Градиент имеет вид: $\\nabla x^\\top A x = (A+A^\\top)x =$ [при симметричной матрице $A$] $= 2Ax$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "def grad_function(x: NDArray, A: NDArray, mu: NDArray) -> NDArray:\n",
    "    return 2 * A @ (x - mu)\n",
    "\n",
    "\n",
    "def grad_limitation(x: NDArray) -> NDArray:\n",
    "    return 2 * x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_optimality(x: NDArray, A: NDArray, mu: NDArray) -> bool:\n",
    "    return grad_limitation(x) @ -grad_function(x, A, mu) >= 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Исследование на выпуклость"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Дана квадратичная функция $f(x)=(x-\\mu_0)^\\top A (x-\\mu_0)$, где $A \\in \\mathbb{R}^{n^2}$ - симметричная, положительно определенная матрица. Ограничение $c(x)$ выпукло.\n",
    "Когда матрица коэффициентов $A$ - положительно определена, функция $f(x)$ будет выпуклой.\n",
    "\n",
    "\n",
    "Проверим этот факт через условие выпуклости:\n",
    "\n",
    "$f(\\lambda x + (1− \\lambda)y) \\leq \\lambda f(x) + (1− \\lambda)f(y)$, где $0 \\geq \\lambda \\leq 1$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_n = 100\n",
    "test_A = get_symmetric_matrix(test_n)\n",
    "\n",
    "test_mu = np.ones(test_n)\n",
    "test_x = np.random.random(test_n)\n",
    "test_y = np.random.random(test_n)\n",
    "\n",
    "\n",
    "def test(test_x: NDArray, test_y: NDArray, test_A: NDArray, test_mu: NDArray, test_lambda: float) -> bool:\n",
    "    return function(test_lambda*test_x + (1-test_lambda)*test_y, test_A, test_mu) \\\n",
    "            <= test_lambda * function(test_x, test_A, test_mu) + (1-test_lambda) * function(test_y, test_A, test_mu)\n",
    "\n",
    "results = [\n",
    "    test(test_x, test_y, test_A, test_mu, test_lambda) for test_lambda in np.linspace(0, 1, 10)\n",
    "]\n",
    "\n",
    "all(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Для каждого значения $n \\in \\{10, 20,\\dots, 100\\}$ сгенерируйте $N = 100$ тестовых примеров. В каждом случае найдите глобальный минимум, $x^* \\in \\mathbb{R}^n$, с помощью CVX. Проверьте, что в точке минимума выполняется условие оптимальности (т.е. вектора градиента к ограничению и антиградиента к целевой функции сонаправлены).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Описание тестовых данных\n",
    "\n",
    "Для проведения экспериментов согдана система хранения данных для экспериментов:\n",
    "\n",
    "* Размерность задачи $\\{10, 20, \\dots, 100\\}$\n",
    "    * Для каждого из них свой набор из 100 тестовых згначений матрицы $A$\n",
    "        * Для каждого из значения $A$ свой набор стартовых точек $x_{0}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class TestCase:\n",
    "    A: NDArray\n",
    "    default_x: list[NDArray] = field(default_factory=list)\n",
    "    solver_x: NDArray = None\n",
    "    my_x: list[NDArray] = field(default_factory=list)\n",
    "    num_iterations: list[int] = field(default_factory=list)\n",
    "    time: list[int] = field(default_factory=list)\n",
    "    accuracy: list[float] = field(default_factory=list)\n",
    "\n",
    "\n",
    "def generate_data(min_dim: int, max_dim: int, step_dim: int, num_test_cases: int, num_experiments: int) -> Dict[int, List[TestCase]]:\n",
    "    dimensionality_range = range(min_dim, max_dim+1, step_dim)\n",
    "\n",
    "    data = defaultdict(list)\n",
    "    for n in dimensionality_range:\n",
    "        for _ in range(num_test_cases):\n",
    "            A = get_symmetric_matrix(n)\n",
    "            test_case = TestCase(A)\n",
    "            for _ in range(num_experiments):\n",
    "                x = np.random.random(n)\n",
    "                test_case.default_x.append(x)\n",
    "            data[n].append(test_case)\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data = generate_data(\n",
    "    min_dim=10,\n",
    "    max_dim=100,\n",
    "    step_dim=10,\n",
    "    num_test_cases=100,\n",
    "    num_experiments=100\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "float_calculation_tol = 1e-4\n",
    "\n",
    "for n, test_cases in test_data.items():\n",
    "    mu = np.ones(n)\n",
    "\n",
    "    for test_case in test_cases:\n",
    "        x_started = test_case.default_x[0]\n",
    "\n",
    "        x = cp.Variable(n)\n",
    "        optimization_func = cp.quad_form(x=(x - mu), P=test_case.A)\n",
    "        objective = cp.Minimize(optimization_func)\n",
    "\n",
    "        constraints = [\n",
    "            cp.sum_squares(x) <= 1\n",
    "        ]\n",
    "\n",
    "        problem = cp.Problem(objective, constraints)\n",
    "        problem.solve(solver=cp.SCS)\n",
    "\n",
    "        test_case.solver_x = x.value\n",
    "\n",
    "        if not check_optimality(x.value, test_case.A, mu):\n",
    "            print(f'Optimality condition is not satisfied.')\n",
    "\n",
    "        if limitation(x.value) - 1 > float_calculation_tol:\n",
    "            print('Constraint error')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В данном эксперименте мы воспользовались библиотекой *cvxpy* и солвером *SCS* для решения выпуклой задачи оптимизации с ограничениями."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Для каждого значения $n \\in \\{10, 20,\\dots, 100\\}$ и для каждого тестового примера сгенерируйте 100 начальных точек. В зависимости от варианта реализуйте следующие методы решения задачи (1) для заданной точности $\\epsilon = 0.01$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Градиентный спуск c *Exact Line Search*\n",
    "\n",
    "Градиентный спуск с Exact Line Search — это метод оптимизации, используемый для нахождения минимума функции. Он основан на итеративном движении в направлении, противоположном градиенту функции в текущей точке, что соответствует направлению наискорейшего убывания функции.\n",
    "\n",
    "\n",
    "#### Принцип работы:\n",
    "\n",
    "1. **Вычисление градиента**: На каждом шаге вычисляется градиент функции потерь в текущей точке $x$. Градиент $\\nabla f(x)$ указывает направление наискорейшего роста функции.\n",
    "\n",
    "2. **Exact Line Search**: Затем выполняется поиск вдоль линии. Это означает, что в направлении, противоположном градиенту, ищется такой размер шага $s$, который минимизирует функцию потерь $f(x - s \\Delta x)$.\n",
    "\n",
    "3. **Обновление точки**: После того как найден оптимальный размер шага, текущая точка $x$ обновляется, чтобы приблизиться к минимуму функции.\n",
    "\n",
    "\n",
    "#### Формально может быть записан в виде:\n",
    "\n",
    "Повторять, пока не достигнуто условие остановки $||\\nabla f(x)||_{2} \\leq \\epsilon$, где $\\epsilon > 0$:\n",
    "1. Определить градиент функции в точке $\\Delta x = \\nabla f(x)$.\n",
    "2. *Exact Line Search*. Определить шаг алгоритма $s \\geq 0$:\n",
    "    1. Найти такой шаг градиента $s$ (*learning rate*), который приводит к наиболее оптимальному решению: $\\argmin_{s \\geq 0}f(x - s \\Delta x)$\n",
    "3. Обновление точки. $x = x - s\\Delta x$.\n",
    "\n",
    "\n",
    "#### Преимущества:\n",
    "\n",
    "- Exact Line Search позволяет точно определить размер шага на каждой итерации, что может ускорить сходимость к минимуму.\n",
    "- Отсутствие фиксированного параметра learning rate, фактически он подбирается автоматически для каждого шага оптимизации.\n",
    "- Простота имплементации.\n",
    "\n",
    "#### Недостатки:\n",
    "\n",
    "- Нахождение оптимального размера шага на каждом шаге может быть вычислительно затратным.\n",
    "- Метод может застрять в локальных минимумах, а не находить глобальный минимум.\n",
    "- Результат оптимизации может зависеть от выбора начальной точки.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_verbose(string: str, verbose: bool) -> None:\n",
    "    if verbose:\n",
    "        print(string, flush=True)\n",
    "\n",
    "\n",
    "def print_iteration(iteration: int, y: int, x: NDArray, verbose: bool) -> None:\n",
    "    print_verbose(f'Iteration {iteration}, y: {y}, x: {x}', verbose)\n",
    "\n",
    "\n",
    "def get_exact_line_alpha(func: Callable,\n",
    "                         x: NDArray, A: NDArray, mu: NDArray, delta_x: NDArray,\n",
    "                         min_s: float = 0, max_s: float = 1., step_s: float = 0.001) -> float:\n",
    "    s_values = np.arange(min_s+step_s, max_s, step_s)\n",
    "    func_results = [func(x-s*delta_x, A, mu) for s in s_values]\n",
    "    return s_values[np.argmin(func_results)]\n",
    "\n",
    "\n",
    "@dataclass\n",
    "class GradDescentResult:\n",
    "    x: NDArray\n",
    "    y: float\n",
    "    time: float\n",
    "    iterations: int\n",
    "    accuracy: float\n",
    "\n",
    "\n",
    "def grad_desc_exact_line(*,\n",
    "                    x: NDArray,\n",
    "                    A: NDArray,\n",
    "                    func: Callable,\n",
    "                    grad_func: Callable,\n",
    "                    epsilon: float = 1.e-2,\n",
    "                    max_iters: int = 1e5,\n",
    "                    min_s: float = 0.,\n",
    "                    max_s: float = 0.5,\n",
    "                    step_s: float = 1e-5,\n",
    "                    verbose: bool = False) -> GradDescentResult:\n",
    "    \"\"\"\n",
    "    gradient descent with exact line minimization\n",
    "    \"\"\"\n",
    "    start_time = time.time()\n",
    "\n",
    "    mu = np.ones_like(x)\n",
    "\n",
    "    print_iteration(0, func(x, A, mu), x, verbose=verbose)\n",
    "\n",
    "    for iteration in range(1, int(max_iters)+1):\n",
    "\n",
    "        delta_x = grad_func(x, A, mu)\n",
    "\n",
    "        if np.linalg.norm(delta_x) < epsilon:\n",
    "            print_verbose('STOP Condition', verbose=verbose)\n",
    "            break\n",
    "\n",
    "        exact_alpha = get_exact_line_alpha(func, x, A, mu, delta_x, min_s, max_s, step_s)\n",
    "        print_verbose(f'Selected alpha is {exact_alpha}', verbose=verbose)\n",
    "\n",
    "        x -= exact_alpha * delta_x\n",
    "    else:\n",
    "        print_verbose('STOP Condition', verbose=verbose)\n",
    "\n",
    "    end_time = time.time()\n",
    "\n",
    "    result = GradDescentResult(x=x,\n",
    "                               y=func(x, A, mu),\n",
    "                               time=end_time-start_time,\n",
    "                               iterations=iteration,\n",
    "                               accuracy=np.linalg.norm(grad_func(x, A, mu)))\n",
    "    print_verbose(f'Optimal y: {result.y}, obtained in {result.x}', verbose=verbose)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[n=10]: Avg time 1.699621 Avg iter 81.00 Avg accuracy 0.01\n",
      "[n=20]: Avg time 5.041990 Avg iter 226.00 Avg accuracy 0.01\n",
      "[n=30]: Avg time 13.225054 Avg iter 2991.00 Avg accuracy 0.01\n",
      "[n=40]: Avg time 16.305452 Avg iter 3648.50 Avg accuracy 0.01\n",
      "[n=50]: Avg time 19.149586 Avg iter 4075.00 Avg accuracy 0.01\n",
      "[n=60]: Avg time 49.831344 Avg iter 5873.50 Avg accuracy 0.02\n",
      "[n=70]: Avg time 89.318018 Avg iter 5503.00 Avg accuracy 0.01\n",
      "[n=80]: Avg time 100.137591 Avg iter 3507.00 Avg accuracy 0.01\n",
      "[n=90]: Avg time 385.716565 Avg iter 100000.00 Avg accuracy 19018.81\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for n, test_cases in test_data.items():\n",
    "    mu = np.ones(n)\n",
    "\n",
    "    for test_case_id, test_case in enumerate(test_cases):\n",
    "\n",
    "        for x_started in test_case.default_x:\n",
    "\n",
    "            result = grad_desc_exact_line(x=x_started, A=test_case.A, func=function, grad_func=grad_function, verbose=False)\n",
    "\n",
    "            test_case.my_x.append(result.x)\n",
    "            test_case.time.append(result.time)\n",
    "            test_case.num_iterations.append(result.iterations)\n",
    "            test_case.accuracy.append(result.accuracy)\n",
    "\n",
    "    print(f'[n={n}]: Avg time {np.mean(test_case.time):.6f} Avg iter {np.mean(test_case.num_iterations):.2f} Avg accuracy {np.mean(test_case.accuracy):.2f}', flush=True)\n",
    "\n",
    "with open(results_dump_file, 'wb') as handle:\n",
    "    pickle.dump(test_data, handle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Среднее время искажено, так как для экспериментов использовалось HW без активного охлаждения (Apple Silicon M1), на больших размерностях было заметено сильное снижение вычислительной мощности."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(results_dump_file, 'rb') as handle:\n",
    "    test_data = pickle.load(handle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Done] Объясните принцип работы метода, опишите его преимущества и недостатки."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Done] Для каждого значения $n \\in \\{10,20,\\dots,100\\}$ подсчитайте среднее время работы метода и среднее число итераций (усреднение проводится по всем начальным точкам и по всем тестовым примерам)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Done] Для одного тестового примера при $n = 10$ и нескольких различных начальных точек постройте зависимость точности от числа итераций. [Done] Зависит ли скорость сходимости метода от отношения максимального и минимального собственных чисел матрицы $A$?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Точность в виде $||\\\\nabla f(x)||_{2} $')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "'''\n",
    "Для одного тестового примера при $n = 10$ и нескольких различных начальных\n",
    "точек постройте зависимость точности от числа итераций.\n",
    "'''\n",
    "\n",
    "test_case = test_data[10][0]\n",
    "\n",
    "axes = plt.gca()\n",
    "axes.scatter(test_case.num_iterations, test_case.accuracy)\n",
    "axes.set_xlabel('Число итераций')\n",
    "axes.set_ylabel('Точность в виде $||\\\\nabla f(x)||_{2} $')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "На тестовом наборе данных сильная зависимость точности от числа итераций не была выявлена. Это связано с тем, что какая бы начальная точка не была выбрана, критерий остановки - заданная точность 0.01. Для проверки гипотезы связи точности с количеством итераций, необходимо провести дополнительтный эксперимент, где критерий остановки алгоритма - $n$ итераций оптимизации."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Число итераций (Скорость сходимости)')"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "'''Зависит ли скорость сходимости метода от отношения максимального\n",
    "и минимального собственных чисел матрицы $A$?\n",
    "'''\n",
    "\n",
    "data_x = []\n",
    "data_y = []\n",
    "\n",
    "for test_case in test_data[10]:\n",
    "    eigenvalues = np.linalg.eigvals(test_case.A)\n",
    "    ratio = max(eigenvalues)/ min(eigenvalues)\n",
    "\n",
    "    data_x.append(ratio)\n",
    "    data_y.append(np.mean(test_case.num_iterations))\n",
    "\n",
    "axes = plt.gca()\n",
    "axes.scatter(data_x, data_y)\n",
    "\n",
    "axes.set_xlabel('Отношения max и min собственных чисел $A$')\n",
    "axes.set_ylabel('Число итераций (Скорость сходимости)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В данном эксперименте мы моджем наблюдать отсутствие связи между числом итераций и максимальным отношением собственных чисел матрицы $A$. Однако на графике замметен выброс, причем при различных запусках, как минимум один выброс удается обнаружить. Возможно это связано с особенностями генерации матрицы $A$."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}