Notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b5113281",
   "metadata": {},
   "source": [
    "# Optimization Algorithms for Markowitz Portfolio Problem\n",
    "<hr>\n",
    "\n",
    "## Environment Set Up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "421495ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os.path\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.spatial import distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fe767b78",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Environment variable\n",
    "\n",
    "EPSILON: constant used for the stopping criteria\n",
    "MAX_ITER: maximium numer of iteration allowed (in frank-wolfe algorithm)\n",
    "MAX_ITER_PGM: maximium numer of iteration allowed (in projected gradient algorithm)\n",
    "COLOR_1: color used for plots\n",
    "\"\"\"\n",
    "EPSILON = 1e-5\n",
    "MAX_ITER = int(1 / EPSILON)\n",
    "MAX_ITER_PGM = 5000\n",
    "COLOR_1 = '#d63227'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03400ad6",
   "metadata": {},
   "source": [
    "## Loading Dataset and Problem Set Up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "416f50ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_dataset(dataset=1):\n",
    "    \"\"\"\n",
    "    This function loads the specified dataset. The dataset can be used to implement\n",
    "    the Markowitz portfolio problem. There are two available datasets:\n",
    "    - Dataset 1: SP_500\n",
    "    - Dataset 2: EuroStoxx50\n",
    "\n",
    "    Args:\n",
    "    dataset (int): Load SP_500 if equal to 1, load EuroStoxx50 if equal to 2\n",
    "\n",
    "    Returns:\n",
    "    name (str): dataset name\n",
    "    n (int): number of available assets\n",
    "    r (np.ndarray): expected return on assets\n",
    "    sigma (np.ndarray): covariance matrix\n",
    "    \"\"\"\n",
    "    \n",
    "    if dataset == 1:\n",
    "        \n",
    "        name = 'SP_500'\n",
    "        path = os.path.join(\"Datasets\", \"SP_500\", \"data\")\n",
    "\n",
    "        r = np.genfromtxt(fname = os.path.join(path, 'MRet476.txt'))\n",
    "        sigma = np.genfromtxt(fname = os.path.join(path, 'Cov476.txt'))\n",
    "        n = r.shape[0]\n",
    "\n",
    "    elif dataset == 2:\n",
    "        \n",
    "        name = 'EUROSTOXX_50'\n",
    "        path = os.path.join(\"Datasets\", \"EUROSTOXX_50\", \"data\")\n",
    "\n",
    "        r = np.genfromtxt(fname = os.path.join(path, 'MRet48.txt'))\n",
    "        sigma = np.genfromtxt(fname = os.path.join(path, 'Cov48.txt'))\n",
    "        n = r.shape[0]\n",
    "\n",
    "    else:\n",
    "        \n",
    "        name = 'SYNTHETIC_DATA'\n",
    "\n",
    "        n = 10\n",
    "        r = np.random.normal(size=n)\n",
    "        var = np.random.normal(size=n).reshape(1, -1)\n",
    "        sigma = var.T @ var\n",
    "        \n",
    "        x = np.random.randint(0, 100, n)\n",
    "        x = x / sum(x)\n",
    "    \n",
    "    return name, n, r, sigma"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "483398c9",
   "metadata": {},
   "source": [
    "### Variables initialization\n",
    "Here, we load the specified dataset and set up the Markowitz portfolio problem initializing the following variables:\n",
    "\n",
    "<code>n</code> : number of available assets\n",
    "\n",
    "<code>r</code> : expected return on assets\n",
    "\n",
    "<code>sigma</code> : covariance matrix\n",
    "\n",
    "<code>eta</code> : risk-aversion parameter (must be > 0)\n",
    "\n",
    "<code>x</code> : amount invested in each asset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bfecfec9",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Dataset Description\n",
      "\n",
      "Name: EUROSTOXX_50\n",
      "Number of Stocks: 48\n",
      "Risk-aversion parameter (eta) = 1\n",
      "Expected return vector shape: (48,)\n",
      "Covariance Matrix shape: (48, 48)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "name, n, r, sigma = load_dataset(dataset=2) # Loading the dataset\n",
    "eta = 1 # It can be chosen arbitrarily (must be > 0)\n",
    "x = np.zeros(n) # Initialized as a vector of zeros\n",
    "\n",
    "print(\n",
    "f'''\n",
    "Dataset Description\n",
    "\n",
    "Name: {name}\n",
    "Number of Stocks: {n}\n",
    "Risk-aversion parameter (eta) = {eta}\n",
    "Expected return vector shape: {r.shape}\n",
    "Covariance Matrix shape: {sigma.shape}\n",
    "'''\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b844917c",
   "metadata": {},
   "source": [
    "## Objective function and its Gradient"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d11f2415",
   "metadata": {},
   "source": [
    "The objective function can be expressed as:\n",
    "\\begin{align*}\n",
    "f(x) = \\eta \\cdot \\textit{x}^\\top\\Sigma\\textit{x} - \\bar{r}^\\top\\textit{x}\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "822ba7ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    '''\n",
    "    This function compute the cost function w.r.t. x, for the Markowitz problem\n",
    "    '''\n",
    "    return eta * (x.T @ sigma @ x) - r.T @ x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d5e25ab3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff65d27f",
   "metadata": {},
   "source": [
    "The gradient of the objective function can be expressed as:\n",
    "\\begin{align*}\n",
    "    \\nabla f(x) = \\eta \\cdot (x^\\top \\Sigma + \\Sigma x) - \\bar{r}\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2f0ce08d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient(x):\n",
    "    '''\n",
    "    This function compute the gradient of the cost function w.r.t. x, for the Markowitz problem\n",
    "    '''\n",
    "    return eta * ((x @ sigma).T + (sigma @ x)) - r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2aa68264",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.01149914278"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.min(gradient(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17cdc1ac",
   "metadata": {},
   "source": [
    "## Other support functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "348f16e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_weights(x):\n",
    "    '''\n",
    "    This function prints the optimal weights assigned to assets in the portfolio in a human-readable format.\n",
    "    \n",
    "    Args:\n",
    "    x (np.ndarray): Array containing the weights assigned to different assets in a portfolio.\n",
    "    \n",
    "    Returns:\n",
    "    None\n",
    "    '''\n",
    "    print('-'*40)\n",
    "    print(f'Optimal weights (for eta = {eta}):')\n",
    "    print('-'*40)\n",
    "    for i in np.where(x > 0)[0]:\n",
    "        print(f'Asset {i+1}: x = {x[i]*100:.2f}%')\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5a5f85ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------\n",
      "Optimal weights (for eta = 1):\n",
      "----------------------------------------\n",
      "Asset 2: x = 30.00%\n",
      "Asset 4: x = 70.00%\n"
     ]
    }
   ],
   "source": [
    "x = np.array([0., 0.3, 0., 0.7])\n",
    "print_weights(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "150e3ba3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def line_search(fun, dk, xk, min_gamma, max_gamma, n_step=100, verbosity=False):\n",
    "    '''\n",
    "    This function performs a line search to find the best step size 'gamma' that minimizes the given objective \n",
    "    function 'fun' along the direction defined by 'dk' starting from the point 'xk'. The search is constrained \n",
    "    within the range (min_gamma, max_gamma]. The number of steps in the linear search is controlled by 'n_step'.\n",
    "    \n",
    "    Args:\n",
    "        fun (callable): The objective function to be minimized.\n",
    "        dk (np.ndarray): The search direction vector.\n",
    "        xk (np.ndarray): The current point in the search space.\n",
    "        min_gamma (float): The minimum allowable step size (exclusive).\n",
    "        max_gamma (float): The maximum allowable step size (inclusive).\n",
    "        n_step (int, optional): The number of steps to perform in the linear search. Default is 100.\n",
    "\n",
    "    Returns:\n",
    "        float: The optimal step size (gamma) within the specified range that minimizes the objective function.\n",
    "        \n",
    "    '''\n",
    "    gamma = max_gamma # Initial assignment\n",
    "    beta = max_gamma\n",
    "    step_size_reduction = (max_gamma - min_gamma) / n_step\n",
    "    \n",
    "    if verbosity:\n",
    "        print(f'step_size_reduction {step_size_reduction}\\n')\n",
    "        print(f'beta {beta}')\n",
    "    \n",
    "    while beta >= min_gamma :\n",
    "        if fun(xk + beta * dk) < fun(xk + gamma * dk):\n",
    "            gamma = beta\n",
    "            \n",
    "        beta = beta - step_size_reduction\n",
    "        if beta < min_gamma:\n",
    "            break\n",
    "            \n",
    "        if verbosity: \n",
    "            print(f'beta {beta}')\n",
    "    \n",
    "    if verbosity:\n",
    "        print()\n",
    "        print(f'gamma {gamma}', end=''*5)\n",
    "    \n",
    "    return gamma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e40a3a1a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.009999999999999247"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line_search(lambda x: x@x, np.array([0, 1]), np.array([0, 0.5]), min_gamma=0, max_gamma=1, verbosity=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ced09759",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_convergence(x_values, y_values, title='Convergence', xlabel='Iterations', ylabel='Duality Gap', color=COLOR_1):\n",
    "    \"\"\"\n",
    "    Plots the convergence of the algorithm.\n",
    "\n",
    "    Args:\n",
    "    x_values (list)\n",
    "    y_values (list)\n",
    "\n",
    "    Returns:\n",
    "    None\n",
    "    \"\"\"\n",
    "    # Plot style settings\n",
    "    plt.rcParams['font.family'] = 'sans-serif'\n",
    "    plt.rcParams['axes.linewidth'] = 0.8\n",
    "    plt.rcParams['axes.grid'] = False\n",
    "    plt.rcParams['grid.alpha'] = 0.5\n",
    "    plt.rcParams['grid.linestyle'] = '--'\n",
    "    plt.rcParams['grid.linewidth'] = 0.8\n",
    "\n",
    "    # Generate the plot\n",
    "    plt.figure(figsize=(10, 5))\n",
    "    plt.plot(x_values, y_values, linestyle='-', color=color)\n",
    "    plt.xlabel(xlabel, fontsize=12)\n",
    "    plt.ylabel(ylabel, fontsize=12)\n",
    "    plt.title(label=title, fontsize=14)\n",
    "    plt.xticks(fontsize=10)\n",
    "    plt.yticks(fontsize=10)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c4cadf0",
   "metadata": {},
   "source": [
    "## Algorithms implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c708338",
   "metadata": {},
   "source": [
    "### 1. Frank-Wolfe Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "31115c86",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def frank_wolfe(n, r, sigma, eta):\n",
    "    \"\"\"\n",
    "    Implementation of the Frank-Wolfe method (for unit simplex).\n",
    "\n",
    "    Args:\n",
    "    n (int): Number of available assets.\n",
    "    r (np.ndarray): Returns on assets.\\\n",
    "    sigma (np.ndarray): Covariance matrix.\n",
    "    eta (float): Risk-aversion parameter (must be > 0).\n",
    "\n",
    "    Return:\n",
    "    x (np.ndarray): Optimal amount invested in each asset.\n",
    "    iterations (list): A list containing the number of iterations at each step.\n",
    "    duality_gap_values (list): A list recording the duality gap values at each iteration.\n",
    "    f_values (list): A list recording the objective function values at each iteration.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    # Initialize variables\n",
    "    s = np.zeros(n)  # Initialize s\n",
    "    gamma = 0  # Initialize gamma\n",
    "    duality_gap = 0  # Initialize duality gap\n",
    "\n",
    "    # Initialize x array to one of the atoms of the simplex\n",
    "    x = np.zeros(n)\n",
    "    i = np.random.randint(low=0, high=n)\n",
    "    x[i] = 1\n",
    "\n",
    "    # Initialize lists to track convergence\n",
    "    duality_gap_values = []  # To record duality gap values\n",
    "    iterations = []  # To record the number of iterations\n",
    "    f_values = [] # To record objective function values\n",
    "\n",
    "    for k in range(MAX_ITER):\n",
    "\n",
    "        # Set s = e_i\n",
    "        i = np.argmin(gradient(x))\n",
    "        s = np.zeros(n)\n",
    "        s[i] = 1\n",
    "        \n",
    "        # Compute the duality gap as a stopping criterion\n",
    "        duality_gap = -gradient(x).T @ (s - x)\n",
    "        duality_gap_values.append(duality_gap)  # Record duality gap value\n",
    "        iterations.append(k)  # Record the number of iterations\n",
    "        f_values.append(f(x)) # Record cost function value\n",
    "\n",
    "        if k%(MAX_ITER//100)==0 or k==MAX_ITER-1 or duality_gap <= EPSILON:\n",
    "            print(f'>>> Iter {k:04d}', end=' '*5)\n",
    "            print(f'i = {i}', end=' '*5)\n",
    "            print(f'f(x) = {f(x):.2e}', end=' '*5)\n",
    "            print(f'gap = {duality_gap:.2e}', end=' '*5)\n",
    "            #print(f'gamma = {gamma:.3f}', end=' '*5)\n",
    "            print()\n",
    "            \n",
    "        # Check the stopping condition based on the duality gap\n",
    "        if duality_gap <= EPSILON:\n",
    "            print(f'Stopping criteria reached')\n",
    "            break\n",
    "        \n",
    "        # Line search to find the optimal step size gamma in the range (0, gamma_hat]\n",
    "        gamma = line_search(fun=f, dk=(s - x), xk=x, min_gamma=0, max_gamma=1, n_step=100)\n",
    "        \n",
    "        # Compute the update step\n",
    "        x = x + gamma * (s - x)\n",
    "\n",
    "    print(f'Stopping alghorithm after {k+1} iterations\\n')\n",
    "\n",
    "    return x, iterations, duality_gap_values, f_values\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d5c863cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>> Iter 0000     i = 22     f(x) = -1.58e-04     gap = 1.21e-02     \n",
      ">>> Iter 0186     i = 17     f(x) = -7.44e-03     gap = 7.46e-06     \n",
      "Stopping criteria reached\n",
      "Stopping alghorithm after 187 iterations\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x_FW, iterations_FW, duality_gap_values_FW, f_values_FW = frank_wolfe(n, r, sigma, eta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "17128b0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------\n",
      "Optimal weights (for eta = 1):\n",
      "----------------------------------------\n",
      "Asset 17: x = 0.08%\n",
      "Asset 18: x = 18.29%\n",
      "Asset 23: x = 25.63%\n",
      "Asset 27: x = 13.96%\n",
      "Asset 29: x = 24.78%\n",
      "Asset 39: x = 17.27%\n"
     ]
    }
   ],
   "source": [
    "print_weights(x_FW)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5504fdf2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_convergence(iterations_FW, f_values_FW, title='Convergence of the Frank-Wolfe Algorithm', ylabel='f(x)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "dc442f59",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_convergence(iterations_FW, duality_gap_values_FW, title='Convergence of the Frank-Wolfe Algorithm')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89236d66",
   "metadata": {},
   "source": [
    "### 2. Pariwise Frank-Wolfe Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "8f2a5be5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pairwise_frank_wolfe(n, r, sigma, eta):\n",
    "    \"\"\"\n",
    "    Implementation of the Pairwise Frank-Wolfe method (for the unit simplex).\n",
    "\n",
    "    Args:\n",
    "    n (int): number of available assets\n",
    "    r (np.ndarray): returns on assets\n",
    "    sigma (np.ndarray): covariance matrix\n",
    "    eta (float): risk-aversion parameter (must be > 0)\n",
    "\n",
    "    Returns:\n",
    "    x (np.ndarray): optimal investment amounts in each asset\n",
    "    iterations (list): A list containing the number of iterations at each step.\n",
    "    duality_gap_values (list): A list recording the duality gap values at each iteration.\n",
    "    f_values (list): A list recording the objective function values at each iteration.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    # Initialize variables\n",
    "    s = np.zeros(n) # search atom\n",
    "    v = np.zeros(n) # away atom\n",
    "    d_FW = np.zeros(n)\n",
    "    d_AS = np.zeros(n)\n",
    "    d = np.zeros(n)\n",
    "    gamma = 0\n",
    "    gamma_max = 0\n",
    "    active_set = []  # active set, i.e., a list containing the previously discovered search atoms\n",
    "\n",
    "    # Initialize the x array to one of the atoms of the simplex\n",
    "    x = np.zeros(n)\n",
    "    i_FW = np.random.randint(low=0, high=n)\n",
    "    i_AS = 0\n",
    "    x[i_FW] = 1\n",
    "    active_set.append(x)  # add this atom to the active set\n",
    "\n",
    "    # Initialize lists to track convergence\n",
    "    duality_gap_values = []  # To record duality gap values\n",
    "    iterations = []  # To record the number of iterations\n",
    "    f_values = [] # To record cost function values\n",
    "\n",
    "    for k in range(MAX_ITER):\n",
    "\n",
    "        # Compute the gradient of f(x) with respect to the current iterate x\n",
    "        grad = gradient(x)\n",
    "\n",
    "        # Set s\n",
    "        i_FW = np.argmin(grad)\n",
    "        s = np.zeros(n)\n",
    "        s[i_FW] = 1\n",
    "     \n",
    "        # Set v\n",
    "        if active_set:\n",
    "            v = active_set[0]\n",
    "            for z in active_set[1:]:\n",
    "                if (grad @ (z - x)) > (grad @ (v - x)):\n",
    "                    v = z\n",
    "        i_AS = np.where(v > 0)[0][0]\n",
    "        \n",
    "        # Set Frank-Wolfe direction and away-step direction\n",
    "        d_FW = s - x\n",
    "        d_AS = x - v\n",
    "\n",
    "        # Set direction d\n",
    "        d = d_FW + d_AS\n",
    "\n",
    "        # Compute the duality gap as a stopping criterion\n",
    "        duality_gap = -grad.T @ d_FW\n",
    "        duality_gap_values.append(duality_gap)  # Record duality gap value\n",
    "        iterations.append(k)  # Record the number of iterations\n",
    "        f_values.append(f(x)) # Record cost function value\n",
    "\n",
    "        if k%(MAX_ITER//10)==0 or k==MAX_ITER-1 or duality_gap <= EPSILON:\n",
    "            print(f'>>> Iter {k:03d}', end=' ' * 5)\n",
    "            print(f'i_FW = {i_FW}', end=' ' * 5)\n",
    "            print(f'i_AS = {i_AS}', end=' ' * 5)\n",
    "            print(f'f(x) = {f(x):.2e}', end=' ' * 5)\n",
    "            print(f'gap = {duality_gap:.2e}', end=' ' * 5)\n",
    "            print(f'active_set = {[np.where(a > 0)[0][0] for a in active_set]}', end=' ' * 5)\n",
    "            print()\n",
    "\n",
    "        # Check the stopping condition based on the duality gap\n",
    "        if duality_gap <= EPSILON:\n",
    "            print(f'Stopping criteria reached')\n",
    "            break\n",
    "\n",
    "        # Set the maximum feasible step size (gamma_max)\n",
    "        gamma_max = x[i_AS]\n",
    "\n",
    "        # Line search to find the optimal step size gamma in the range (0, gamma_max]\n",
    "        gamma = line_search(fun=f, dk=d, xk=x, min_gamma=0, max_gamma=gamma_max, n_step=100)\n",
    "\n",
    "        # Compute the update step\n",
    "        x = x + gamma * d\n",
    "        x = x / np.sum(x)\n",
    "\n",
    "        # Update the active set \n",
    "        if not any(np.array_equal(s, arr) for arr in active_set): # Add new atom\n",
    "            active_set.append(s)\n",
    "        if gamma == gamma_max: # Drop Step\n",
    "            active_set.remove(v)\n",
    "\n",
    "    print(f'Stopping algorithm after {k+1} iterations\\n')\n",
    "\n",
    "    return x, iterations, duality_gap_values, f_values\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "47bfd408",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>> Iter 000     i_FW = 22     i_AS = 35     f(x) = -2.76e-03     gap = 9.49e-03     active_set = [35]     \n",
      ">>> Iter 010     i_FW = 22     i_AS = 17     f(x) = -7.44e-03     gap = 8.48e-06     active_set = [22, 28, 38, 26, 17]     \n",
      "Stopping criteria reached\n",
      "Stopping algorithm after 11 iterations\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x_FWP, iterations_FWP, duality_gap_values_FWP, f_values_FWP = pairwise_frank_wolfe(n, r, sigma, eta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "917414d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------\n",
      "Optimal weights (for eta = 1):\n",
      "----------------------------------------\n",
      "Asset 18: x = 19.38%\n",
      "Asset 23: x = 25.56%\n",
      "Asset 27: x = 13.64%\n",
      "Asset 29: x = 24.45%\n",
      "Asset 39: x = 16.97%\n"
     ]
    }
   ],
   "source": [
    "print_weights(x_FWP)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "588e910f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_convergence(iterations_FWP[:], f_values_FWP[:], title='Convergence of the Pairwise Frank-Wolfe Algorithm', ylabel='f(x)', color='blue')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c13e6570",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_convergence(iterations_FWP[:], duality_gap_values_FWP[:], title='Convergence of the Pairwise Frank-Wolfe Algorithm', color='blue')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "955b32d4",
   "metadata": {},
   "source": [
    "### 3. Projected Gradient Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9f682f72",
   "metadata": {},
   "outputs": [],
   "source": [
    "def project_onto_simplex(y):\n",
    "    '''\n",
    "    Projects a given vector onto the unit simplex. The algorithm used for projection is based on the algorithm 1 \n",
    "    described in the paper \"Fast projection onto the simplex and the l1 ball\" - (Condat 2016). \n",
    "    (https://doi.org/10.1007/s10107-015-0946-6)\n",
    "\n",
    "    Args:\n",
    "    y (np.ndarray): The input vector to be projected onto the simplex.\n",
    "\n",
    "    Returns:\n",
    "    np.ndarray: The projected vector that satisfies the constraints of a unit simplex.\n",
    "    \n",
    "    The function takes an input vector 'y' and projects it onto a probability simplex, ensuring that the resulting vector\n",
    "    satisfies the conditions of a probability distribution, where all elements are non-negative and sum up to 1. The\n",
    "    algorithm used for projection is based on the \"Smallest Simplex Projection\" method.\n",
    "    \n",
    "    '''\n",
    "    \n",
    "    n = y.shape[0]\n",
    "    a = 1 # 'a' represent the target sum of the projected vector\n",
    "    \n",
    "    # Sort 'y' into 'u' in descending order.\n",
    "    u = np.sort(y)[::-1]\n",
    "    \n",
    "    # Find the largest index 'k' where the condition (cum_sum - a) / indices < u is met.\n",
    "    cum_sum = np.cumsum(u) - a\n",
    "    indices = np.arange(1, n + 1)\n",
    "    k = np.max(np.where((cum_sum) / indices < u)[0])\n",
    "    \n",
    "    # Set 'tau'\n",
    "    tau = (np.sum(u[:k+1]) - a) / (k+1)\n",
    "    \n",
    "    # Compute the projected vector\n",
    "    x = np.maximum(y - tau, 0)\n",
    "\n",
    "    return x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "87e916bc",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def projected_gradient_method(n, r, sigma, eta, s=115):\n",
    "    \"\"\"\n",
    "    Implementation of the Projected Gradient Method.\n",
    "\n",
    "    Args:\n",
    "    n (int): number of available assets\n",
    "    r (np.ndarray): returns on assets\n",
    "    sigma (np.ndarray): covariance matrix\n",
    "    eta (float): risk-aversion parameter (must be > 0)\n",
    "\n",
    "    Returns:\n",
    "    x (np.ndarray): optimal amount invested in each asset\n",
    "    iterations (list): A list containing the number of iterations at each step.\n",
    "    g_values (list): A list recording the gradient mapping values at each iteration.\n",
    "    f_values (list): A list recording the objective function values at each iteration.\n",
    "\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    # Initialize variables\n",
    "    x_hat = np.zeros(n)\n",
    "    s = s\n",
    "    gamma = 0\n",
    "\n",
    "    # Initialize the x array to one of the atoms of the simplex\n",
    "    x = np.zeros(n)\n",
    "    i = np.random.randint(low=0, high=n)\n",
    "    x[i] = 1\n",
    "\n",
    "    # Initialize lists to track convergence\n",
    "    g_values = []  # To record gradient mapping values\n",
    "    iterations = []  # To record the number of iterations\n",
    "    f_values = [] # To record cost function values\n",
    "\n",
    "    for k in range(MAX_ITER_PGM):\n",
    "\n",
    "        # Set x_hat as the projection of x onto the unit simplex\n",
    "        x_hat = project_onto_simplex(x - s * gradient(x))\n",
    "\n",
    "        # Compute the gradient mapping Euclidean norm as a stopping criterion\n",
    "        g = distance.euclidean(x, x_hat)\n",
    "        g_values.append(g)  # Record gradient mapping value\n",
    "        iterations.append(k)  # Record the number of iterations\n",
    "        f_values.append(f(x)) # Record cost function value\n",
    "        \n",
    "        if k%(MAX_ITER_PGM//10) == 0 or k == 0 or k == MAX_ITER_PGM-1 or g <= EPSILON:\n",
    "            print(f'>>> Iter {k:03d}', end=' ' * 5)\n",
    "            print(f'f(x) = {f(x):.2e}', end=' ' * 5)\n",
    "            print(f'||g|| = {g:.2e}', end=' ' * 5)\n",
    "            print()\n",
    "        \n",
    "        # Check the stopping condition based on the gradient mapping\n",
    "        # If x is (approximately) equal to x_hat, it is a global minimum (Proposition 5.9)\n",
    "        if g <= EPSILON:\n",
    "            print(f'Stopping criteria reached')\n",
    "            break\n",
    "\n",
    "        # Line search to find the optimal step size gamma in the range (0, 1]\n",
    "        gamma = line_search(fun=f, dk=(x_hat - x), xk=x, min_gamma=0, max_gamma=1, n_step=100)\n",
    "\n",
    "        # Compute the update step\n",
    "        x = x + gamma * (x_hat - x)\n",
    "\n",
    "    print(f'Stopping algorithm after {k+1} iterations\\n')\n",
    "\n",
    "    return x, iterations, g_values, f_values\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "fd173b04",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>> Iter 000     f(x) = -1.58e-04     ||g|| = 1.00e+00     \n",
      ">>> Iter 070     f(x) = -7.44e-03     ||g|| = 9.76e-06     \n",
      "Stopping criteria reached\n",
      "Stopping algorithm after 71 iterations\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x_PGM, iterations_PGM, g_values_PGM, f_values_PGM = projected_gradient_method(n, r, sigma, eta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "c99f2632",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------\n",
      "Optimal weights (for eta = 1):\n",
      "----------------------------------------\n",
      "Asset 18: x = 18.68%\n",
      "Asset 23: x = 25.63%\n",
      "Asset 27: x = 13.95%\n",
      "Asset 29: x = 24.68%\n",
      "Asset 39: x = 17.05%\n"
     ]
    }
   ],
   "source": [
    "print_weights(x_PGM)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "040a94ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_convergence(iterations_PGM, f_values_PGM, title='Convergence of the Projected Gradient Algorithm', ylabel='f(x)', color='#16c760')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "8b1b54e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_convergence(iterations_PGM, g_values_PGM, title='Convergence of the Projected Gradient Algorithm', ylabel='Gradient Mapping Norm', color='#16c760')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9aff016",
   "metadata": {},
   "source": [
    "## Comparisons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "334673d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot style settings\n",
    "plt.rcParams['font.family'] = 'sans-serif'\n",
    "plt.rcParams['axes.linewidth'] = 0.8\n",
    "plt.rcParams['axes.grid'] = False\n",
    "plt.rcParams['grid.alpha'] = 0.5\n",
    "plt.rcParams['grid.linestyle'] = '--'\n",
    "plt.rcParams['grid.linewidth'] = 0.1\n",
    "\n",
    "# Generate the plot\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(iterations_FW, f_values_FW, linestyle='-', color=COLOR_1, label='Frank-Wolfe')\n",
    "plt.plot(iterations_FWP, f_values_FWP, linestyle='-', color='blue', label='Pairwise Frank-Wolfe')\n",
    "plt.plot(iterations_PGM, f_values_PGM, linestyle='-', color='#16c760', label='Projected Gradient')\n",
    "plt.legend(fontsize=10)\n",
    "plt.xlabel('Iterations', fontsize=12)\n",
    "plt.ylabel('f(x)', fontsize=12)\n",
    "plt.title(label='Convergence', fontsize=14)\n",
    "plt.xticks(fontsize=10)\n",
    "plt.yticks(fontsize=10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "fe23fda4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot style settings\n",
    "plt.rcParams['font.family'] = 'sans-serif'\n",
    "plt.rcParams['axes.linewidth'] = 0.8\n",
    "plt.rcParams['axes.grid'] = False\n",
    "plt.rcParams['grid.alpha'] = 0.5\n",
    "plt.rcParams['grid.linestyle'] = '--'\n",
    "plt.rcParams['grid.linewidth'] = 0.5\n",
    "\n",
    "# Generate the plot\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(iterations_FW, duality_gap_values_FW, linestyle='-', color=COLOR_1, label='Frank-Wolfe')\n",
    "plt.plot(iterations_FWP, duality_gap_values_FWP, linestyle='-', color='blue', label='Pairwise Frank-Wolfe')\n",
    "#plt.plot(iterations_PGM, f_values_PGM, linestyle='-', color='green', label='PGM')\n",
    "plt.legend(fontsize=10)\n",
    "plt.xlabel('Iterations', fontsize=12)\n",
    "plt.ylabel('Gap', fontsize=12)\n",
    "plt.title(label='Convergence', fontsize=14)\n",
    "plt.xticks(fontsize=10)\n",
    "plt.yticks(fontsize=10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "4c93f361",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Frank-Wolfe\n",
      "----------------------------------------\n",
      "Optimal weights (for eta = 1):\n",
      "----------------------------------------\n",
      "Asset 17: x = 0.08%\n",
      "Asset 18: x = 18.29%\n",
      "Asset 23: x = 25.63%\n",
      "Asset 27: x = 13.96%\n",
      "Asset 29: x = 24.78%\n",
      "Asset 39: x = 17.27%\n",
      "\n",
      "\n",
      "Pairwise Frank-Wolfe\n",
      "----------------------------------------\n",
      "Optimal weights (for eta = 1):\n",
      "----------------------------------------\n",
      "Asset 18: x = 19.38%\n",
      "Asset 23: x = 25.56%\n",
      "Asset 27: x = 13.64%\n",
      "Asset 29: x = 24.45%\n",
      "Asset 39: x = 16.97%\n",
      "\n",
      "\n",
      "Projected Gradient\n",
      "----------------------------------------\n",
      "Optimal weights (for eta = 1):\n",
      "----------------------------------------\n",
      "Asset 18: x = 18.68%\n",
      "Asset 23: x = 25.63%\n",
      "Asset 27: x = 13.95%\n",
      "Asset 29: x = 24.68%\n",
      "Asset 39: x = 17.05%\n"
     ]
    }
   ],
   "source": [
    "print('Frank-Wolfe')\n",
    "print_weights(x_FW)\n",
    "\n",
    "print('\\n\\nPairwise Frank-Wolfe')\n",
    "print_weights(x_FWP)\n",
    "\n",
    "print('\\n\\nProjected Gradient')\n",
    "print_weights(x_PGM)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61da3e0f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}