Genetic Algorithm Portfolio Optimization.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "short-elimination",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(61, 7)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Date</th>\n",
       "      <th>hdfc</th>\n",
       "      <th>itc</th>\n",
       "      <th>l&amp;t</th>\n",
       "      <th>m&amp;m</th>\n",
       "      <th>sunpha</th>\n",
       "      <th>tcs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>01-07-2022</td>\n",
       "      <td>1406.150024</td>\n",
       "      <td>295.000000</td>\n",
       "      <td>1663.000000</td>\n",
       "      <td>1165.050049</td>\n",
       "      <td>857.250000</td>\n",
       "      <td>3113.800049</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>01-06-2022</td>\n",
       "      <td>1348.000000</td>\n",
       "      <td>273.500000</td>\n",
       "      <td>1558.250000</td>\n",
       "      <td>1093.150024</td>\n",
       "      <td>830.599976</td>\n",
       "      <td>3267.100098</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>01-05-2022</td>\n",
       "      <td>1388.949951</td>\n",
       "      <td>270.649994</td>\n",
       "      <td>1654.500000</td>\n",
       "      <td>1034.349976</td>\n",
       "      <td>860.599976</td>\n",
       "      <td>3364.350098</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>01-04-2022</td>\n",
       "      <td>1384.599976</td>\n",
       "      <td>259.549988</td>\n",
       "      <td>1694.349976</td>\n",
       "      <td>922.099976</td>\n",
       "      <td>928.650024</td>\n",
       "      <td>3546.699951</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>01-03-2022</td>\n",
       "      <td>1470.349976</td>\n",
       "      <td>250.649994</td>\n",
       "      <td>1767.650024</td>\n",
       "      <td>806.549988</td>\n",
       "      <td>914.750000</td>\n",
       "      <td>3739.949951</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Date         hdfc         itc          l&t          m&m      sunpha  \\\n",
       "0  01-07-2022  1406.150024  295.000000  1663.000000  1165.050049  857.250000   \n",
       "1  01-06-2022  1348.000000  273.500000  1558.250000  1093.150024  830.599976   \n",
       "2  01-05-2022  1388.949951  270.649994  1654.500000  1034.349976  860.599976   \n",
       "3  01-04-2022  1384.599976  259.549988  1694.349976   922.099976  928.650024   \n",
       "4  01-03-2022  1470.349976  250.649994  1767.650024   806.549988  914.750000   \n",
       "\n",
       "           tcs  \n",
       "0  3113.800049  \n",
       "1  3267.100098  \n",
       "2  3364.350098  \n",
       "3  3546.699951  \n",
       "4  3739.949951  "
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Import libraries and load monthly stock price data\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from functools import reduce\n",
    "rf= 0.05\n",
    "\n",
    "files=['hdfc.csv','itc.csv','l&t.csv','m&m.csv','sunpha.csv','tcs.csv']\n",
    "dfs=[]\n",
    "\n",
    "for file in files:\n",
    "    temp=pd.read_csv(file)\n",
    "    temp.columns=['Date',file.replace('.csv','')]\n",
    "    dfs.append(temp)\n",
    "\n",
    "stocks = reduce(lambda left,right: pd.merge(left,right,on='Date'), dfs)\n",
    "print(stocks.shape)\n",
    "stocks.sort_index(ascending=False,inplace=True)\n",
    "stocks.drop(labels=[60],axis=0,inplace=True)\n",
    "stocks.reset_index(drop=True,inplace=True)\n",
    "stocks.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "prime-portugal",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 0\n",
      "Expected returns of 0.34438109994629595 with risk of 0.043215036713671204\n",
      "\n",
      "Iteration: 1\n",
      "Expected returns of 0.34432103829671934 with risk of 0.043320434812615105\n",
      "\n",
      "Iteration: 2\n",
      "Expected returns of 0.36088473816231686 with risk of 0.046228804528155\n",
      "\n",
      "Iteration: 3\n",
      "Expected returns of 0.34401205173418276 with risk of 0.04202839656187994\n",
      "\n",
      "Iteration: 4\n",
      "Expected returns of 0.3465143799957026 with risk of 0.042970623967329286\n",
      "\n",
      "Iteration: 5\n",
      "Expected returns of 0.35058251774623406 with risk of 0.04455449104965099\n",
      "\n",
      "Iteration: 6\n",
      "Expected returns of 0.3486595638039946 with risk of 0.043736669763345934\n",
      "\n",
      "Iteration: 7\n",
      "Expected returns of 0.34879801687134027 with risk of 0.04378255707378802\n",
      "\n",
      "Iteration: 8\n",
      "Expected returns of 0.3661275748734824 with risk of 0.048440096089486705\n",
      "\n",
      "Iteration: 9\n",
      "Expected returns of 0.3661802115072936 with risk of 0.04849859741205524\n",
      "\n",
      "Iteration: 10\n",
      "Expected returns of 0.3630720384889552 with risk of 0.047593366227955375\n",
      "\n",
      "Iteration: 11\n",
      "Expected returns of 0.36305904289911184 with risk of 0.0475922374375554\n",
      "\n",
      "Iteration: 12\n",
      "Expected returns of 0.36581818515765463 with risk of 0.04846624121445996\n",
      "\n",
      "Iteration: 13\n",
      "Expected returns of 0.3657946779470401 with risk of 0.04846168927570205\n",
      "\n",
      "Iteration: 14\n",
      "Expected returns of 0.36525095862494456 with risk of 0.04829583540776783\n",
      "\n",
      "Iteration: 15\n",
      "Expected returns of 0.3651362406594251 with risk of 0.04826249934371804\n",
      "\n",
      "Iteration: 16\n",
      "Expected returns of 0.36475183056346466 with risk of 0.048146344428321164\n",
      "\n",
      "Iteration: 17\n",
      "Expected returns of 0.3647478215077169 with risk of 0.048145130713499726\n",
      "\n",
      "Iteration: 18\n",
      "Expected returns of 0.36450395666384283 with risk of 0.04807090098355703\n",
      "\n",
      "Iteration: 19\n",
      "Expected returns of 0.3644904802085524 with risk of 0.048066907552128266\n",
      "\n",
      "Iteration: 20\n",
      "Expected returns of 0.3646078669683419 with risk of 0.04810314147481161\n",
      "\n",
      "Iteration: 21\n",
      "Expected returns of 0.36460482910886033 with risk of 0.04810222134278613\n",
      "\n",
      "Iteration: 22\n",
      "Expected returns of 0.3643649213757869 with risk of 0.04802868401206786\n",
      "\n",
      "Iteration: 23\n",
      "Expected returns of 0.36435760439576803 with risk of 0.0480257552157871\n",
      "\n",
      "Iteration: 24\n",
      "Expected returns of 0.3643606576136486 with risk of 0.04802673131340747\n",
      "\n",
      "Iteration: 25\n",
      "Expected returns of 0.36441190821641184 with risk of 0.04804260357894287\n",
      "\n",
      "Iteration: 26\n",
      "Expected returns of 0.36436031080229786 with risk of 0.04802468427824133\n",
      "\n",
      "Iteration: 27\n",
      "Expected returns of 0.3643613232617249 with risk of 0.04802506571590136\n",
      "\n",
      "Iteration: 28\n",
      "Expected returns of 0.36436243312312655 with risk of 0.04802543755967795\n",
      "\n",
      "Iteration: 29\n",
      "Expected returns of 0.36436471749991367 with risk of 0.048026214932437805\n",
      "\n",
      "Iteration: 30\n",
      "Expected returns of 0.3643723835666818 with risk of 0.04802881696950219\n",
      "\n",
      "Iteration: 31\n",
      "Expected returns of 0.3643731264092866 with risk of 0.048029070371815794\n",
      "\n",
      "Iteration: 32\n",
      "Expected returns of 0.36437323030085544 with risk of 0.04802910780105282\n",
      "\n",
      "Iteration: 33\n",
      "Expected returns of 0.36437341840333975 with risk of 0.04802917051795047\n",
      "\n",
      "Iteration: 34\n",
      "Expected returns of 0.364373446402866 with risk of 0.04802917987995181\n",
      "\n",
      "Iteration: 35\n",
      "Expected returns of 0.36437370881131137 with risk of 0.04802926762572005\n",
      "\n",
      "Iteration: 36\n",
      "Expected returns of 0.3643738721649667 with risk of 0.04802932131758716\n",
      "\n",
      "Iteration: 37\n",
      "Expected returns of 0.364373894261394 with risk of 0.04802932885454872\n",
      "\n",
      "Iteration: 38\n",
      "Expected returns of 0.36437390268620795 with risk of 0.04802933190273996\n",
      "\n",
      "Iteration: 39\n",
      "Expected returns of 0.36437392788160233 with risk of 0.048029340327156264\n",
      "\n",
      "Iteration: 40\n",
      "Expected returns of 0.3643739364796041 with risk of 0.048029343201588935\n",
      "\n",
      "Iteration: 41\n",
      "Expected returns of 0.36437393613120656 with risk of 0.048029343097749644\n",
      "\n",
      "Iteration: 42\n",
      "Expected returns of 0.364373936492438 with risk of 0.048029343228656006\n",
      "\n",
      "Iteration: 43\n",
      "Expected returns of 0.3643739372009203 with risk of 0.048029343505871215\n",
      "\n",
      "Iteration: 44\n",
      "Expected returns of 0.3643739372009203 with risk of 0.048029343505871215\n",
      "\n",
      "Iteration: 45\n",
      "Expected returns of 0.364373937235431 with risk of 0.04802934353141104\n",
      "\n",
      "Iteration: 46\n",
      "Expected returns of 0.36437393724218453 with risk of 0.048029343539978134\n",
      "\n",
      "Iteration: 47\n",
      "Expected returns of 0.3643739373031136 with risk of 0.04802934356706852\n",
      "\n",
      "Iteration: 48\n",
      "Expected returns of 0.3643739373596511 with risk of 0.04802934358897426\n",
      "\n",
      "Iteration: 49\n",
      "Expected returns of 0.36437393748530145 with risk of 0.048029343631559404\n",
      "\n",
      "Iteration: 50\n",
      "Expected returns of 0.36437393740061125 with risk of 0.04802934360827826\n",
      "\n",
      "\n",
      "\n",
      "=====================================================\n",
      "Portfolio of stocks after all the iterations:\n",
      "\n",
      "hdfc : 0.12052834665872329\n",
      "itc : 0.3670105577520343\n",
      "l&t : 0.059822756172273436\n",
      "m&m : 0.30101799590519274\n",
      "sunpha : 0.09048660571016588\n",
      "tcs : 0.06113373780161059\n",
      "\n",
      "Expected returns of 0.36437393740061125 with risk of 0.04802934360827826\n",
      "\n"
     ]
    }
   ],
   "source": [
    "## Define all the functions required for Genetic Algorithm\n",
    "\n",
    "def hist_return(months):\n",
    "    ''' It calculates Stock returns for various months and returns a dataframe.\n",
    "        Input: Months in the form of a list.\n",
    "        Output: Historical returns in the form of a DataFrame. '''\n",
    "    idx=[]\n",
    "    df=pd.DataFrame()\n",
    "    for mon in months:\n",
    "        temp=(stocks.iloc[0,1:] - stocks.iloc[mon,1:])/(stocks.iloc[mon,1:])\n",
    "        idx.append(str(mon)+'_mon_return')\n",
    "        df=pd.concat([df, temp.to_frame().T], ignore_index=True)\n",
    "    df.index=idx\n",
    "    return df\n",
    "\n",
    "##Mean portfolio return = Mean Return * Fractions of Total Capital (Chromosome). \n",
    "# Risk-free rate = 0.05 (assumption) \n",
    "# Standard deviation of portfolio return = (chromosome * Standard deviation)**2 + Covariance * Respective weights in chromosome.\n",
    "def mean_portfolio_return(child):\n",
    "    return np.sum(np.multiply(child,mean_hist_return))\n",
    "def var_portfolio_return(child):\n",
    "    part_1 = np.sum(np.multiply(child,sd_hist_return)**2)\n",
    "    temp_lst=[]\n",
    "    for i in range(6):\n",
    "        for j in range(6):\n",
    "            temp=cov_hist_return.iloc[i][j] * child[i] * child[j]\n",
    "            temp_lst.append(temp)\n",
    "    part_2=np.sum(temp_lst)\n",
    "    return part_1+part_2\n",
    "\n",
    "# Chromosome: Set of genes i.e. fractions of total capital assigned to each asset\n",
    "def chromosome(n):\n",
    "    ''' Generates set of random numbers whose sum is equal to 1\n",
    "        Input: Number of stocks.\n",
    "        Output: Array of random numbers'''\n",
    "    ch = np.random.rand(n)\n",
    "    return ch/sum(ch)\n",
    "\n",
    "## Fitness function : The Sharpe ratio, S = (µ − r)/σ\n",
    "## Maximize return, minimize risk\n",
    "def fitness_fuction(child):\n",
    "    ''' This will return the Sharpe ratio for a particular portfolio.\n",
    "        Input: A child/chromosome (1D Array)\n",
    "        Output: Sharpe Ratio value (Scalar)'''\n",
    "    return (mean_portfolio_return(child)-rf)/np.sqrt(var_portfolio_return(child))\n",
    "\n",
    "def Select_elite_population(population, frac=0.3):\n",
    "    ''' Select elite population from the total population based on fitness function values.\n",
    "        Input: Population and fraction of population to be considered as elite.\n",
    "        Output: Elite population.'''\n",
    "    population = sorted(population,key = lambda x: fitness_fuction(x),reverse=True)\n",
    "    percentage_elite_idx = int(np.floor(len(population)* frac))\n",
    "    return population[:percentage_elite_idx]\n",
    "\n",
    "def mutation(parent):\n",
    "    ''' Randomy choosen elements of a chromosome are swapped\n",
    "        Input: Parent\n",
    "        Output: Offspring (1D Array)'''\n",
    "    child=parent.copy()\n",
    "    n=np.random.choice(range(6),2)\n",
    "    while (n[0]==n[1]):\n",
    "        n=np.random.choice(range(6),2)\n",
    "    child[n[0]],child[n[1]]=child[n[1]],child[n[0]]\n",
    "    return child\n",
    "\n",
    "def Heuristic_crossover(parent1,parent2):\n",
    "    ''' The oﬀsprings are created according to the equation:\n",
    "            Off_spring A = Best Parent  + β ∗ ( Best Parent − Worst Parent)\n",
    "            Off_spring B = Worst Parent - β ∗ ( Best Parent − Worst Parent)\n",
    "                Where β is a random number between 0 and 1.\n",
    "        Input: 2 Parents\n",
    "        Output: 2 Children (1d Array)'''\n",
    "    ff1=fitness_fuction(parent1)\n",
    "    ff2=fitness_fuction(parent2)\n",
    "    diff=parent1 - parent2\n",
    "    beta=np.random.rand()\n",
    "    if ff1>ff2:\n",
    "        child1=parent1 + beta * diff\n",
    "        child2=parent2 - beta * diff\n",
    "    else:\n",
    "        child2=parent1 + beta * diff\n",
    "        child1=parent2 - beta * diff\n",
    "    return child1,child2\n",
    "\n",
    "def Arithmetic_crossover(parent1,parent2):\n",
    "    ''' The oﬀsprings are created according to the equation:\n",
    "            Off spring A = α ∗ Parent1 + (1 −α) ∗ Parent2\n",
    "            Off spring B = (1 −α) ∗ Parent1 + α ∗ Parent2\n",
    "            \n",
    "                Where α is a random number between 0 and 1.\n",
    "        Input: 2 Parents\n",
    "        Output: 2 Children (1d Array)'''\n",
    "    alpha = np.random.rand()\n",
    "    child1 = alpha * parent1 + (1-alpha) * parent2\n",
    "    child2 = (1-alpha) * parent1 + alpha * parent2\n",
    "    return child1,child2\n",
    "\n",
    "def next_generation(pop_size,elite,crossover=Arithmetic_crossover):\n",
    "    ''' Generates new population from elite population with mutation probability as 0.4 and crossover as 0.6. \n",
    "        Over the final stages, mutation probability is decreased to 0.1.\n",
    "        Input: Population Size and elite population.\n",
    "        Output: Next generation population (2D Array).'''\n",
    "    new_population=[]\n",
    "    elite_range=range(len(elite))\n",
    "    #print(elite_range)\n",
    "    while len(new_population) < pop_size:\n",
    "        if len(new_population) > 2*pop_size/3: # In the final stages mutation frequency is decreased.\n",
    "            mutate_or_crossover = np.random.choice([0, 1], p=[0.9, 0.1])\n",
    "        else:\n",
    "            mutate_or_crossover = np.random.choice([0, 1], p=[0.4, 0.6])\n",
    "        #print(mutate_or_crossover)\n",
    "        if mutate_or_crossover:\n",
    "            indx=np.random.choice(elite_range)\n",
    "            new_population.append(mutation(elite[indx]))\n",
    "            #print('Mutation!')\n",
    "        else:\n",
    "            p1_idx,p2_idx=np.random.choice(elite_range,2)\n",
    "            c1,c2=crossover(elite[p1_idx],elite[p2_idx])\n",
    "            chk=0\n",
    "            for gene in range(6):\n",
    "                if c1[gene]<0:\n",
    "                    chk+=1\n",
    "                else:\n",
    "                    chk+=0\n",
    "            if chk>0:\n",
    "                p1_idx,p2_idx=np.random.choice(elite_range,2)\n",
    "                c1,c2=crossover(elite[p1_idx],elite[p2_idx])\n",
    "            \n",
    "            new_population.extend([c1,c2])\n",
    "            #print('Crossover!')    \n",
    "    return new_population\n",
    "\n",
    "\n",
    "hist_stock_returns=hist_return([3,6,12,24,36])\n",
    "#print(hist_stock_returns.info())\n",
    "cols=hist_stock_returns.columns\n",
    "hist_stock_returns[cols] = hist_stock_returns[cols].apply(pd.to_numeric, errors='coerce')\n",
    "#print(hist_stock_returns.info())\n",
    "\n",
    "mean_hist_return=hist_stock_returns.mean()\n",
    "sd_hist_return=hist_stock_returns.std()\n",
    "cov_hist_return=hist_stock_returns.cov()\n",
    "for i in range(6):\n",
    "    cov_hist_return.iloc[i][i]=0\n",
    "\n",
    "\n",
    "    \n",
    "## Determine the Optimum portfolio using Arithmetic Crossover  \n",
    "\n",
    "n=6 # Number of stocks = 6\n",
    "pop_size=100 # initial population = 100\n",
    "\n",
    "# Initial population\n",
    "population = np.array([chromosome(n) for _ in range(pop_size)])\n",
    "\n",
    "# Get initial elite population\n",
    "elite = Select_elite_population(population)\n",
    "\n",
    "iteration=0 \n",
    "Expected_returns=0\n",
    "Expected_risk=1\n",
    "\n",
    "while (Expected_returns < 0.30 or Expected_risk > 0.04) and iteration <= 50:\n",
    "    print('Iteration:',iteration)\n",
    "    population = next_generation(100,elite)\n",
    "    elite = Select_elite_population(population)\n",
    "    Expected_returns=mean_portfolio_return(elite[0])\n",
    "    Expected_risk=var_portfolio_return(elite[0])\n",
    "    print('Expected returns of {} with risk of {}\\n'.format(Expected_returns,Expected_risk))\n",
    "    iteration+=1\n",
    "\n",
    "print('\\n\\n=====================================================\\nPortfolio of stocks after all the iterations:\\n')\n",
    "[print(hist_stock_returns.columns[i],':',elite[0][i]) for i in list(range(6))]\n",
    "\n",
    "print('\\nExpected returns of {} with risk of {}\\n'.format(Expected_returns,Expected_risk))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "premier-content",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 0\n",
      "Expected returns of 0.3387039533751445 with risk of 0.04718559745530146\n",
      "\n",
      "Iteration: 1\n",
      "Expected returns of 0.33031564806085106 with risk of 0.030556972265569624\n",
      "\n",
      "Iteration: 2\n",
      "Expected returns of 0.492728970725487 with risk of 0.07111164951392397\n",
      "\n",
      "Iteration: 3\n",
      "Expected returns of 0.842168789302923 with risk of 0.058158213577873596\n",
      "\n",
      "Iteration: 4\n",
      "Expected returns of 0.8543543338703274 with risk of 0.05909281101495806\n",
      "\n",
      "Iteration: 5\n",
      "Expected returns of 1.3719450683438221 with risk of 0.13749710172154828\n",
      "\n",
      "Iteration: 6\n",
      "Expected returns of 0.9682732610981358 with risk of 0.050067608165278\n",
      "\n",
      "Iteration: 7\n",
      "Expected returns of 0.9682732610981358 with risk of 0.050067608165278\n",
      "\n",
      "Iteration: 8\n",
      "Expected returns of 0.746031697442627 with risk of 0.027005807000034354\n",
      "\n",
      "Iteration: 9\n",
      "Expected returns of 0.8222284601856725 with risk of 0.019722043662927735\n",
      "\n",
      "\n",
      "\n",
      "=====================================================\n",
      "Portfolio of stocks after all the iterations:\n",
      "\n",
      "hdfc : 0.9624242743998885\n",
      "itc : 0.22754872038280088\n",
      "l&t : -0.7250573761101828\n",
      "m&m : 2.0798771754932748\n",
      "sunpha : -1.6657237047390199\n",
      "tcs : 0.12093091057323686\n",
      "\n",
      "Expected returns of 0.8222284601856725 with risk of 0.019722043662927735\n",
      "\n"
     ]
    }
   ],
   "source": [
    "## Determine the Optimum portfolio using Heuristic Crossover\n",
    "\n",
    "n=6 # Number of stocks = 6\n",
    "pop_size=100 # initial population = 100\n",
    "\n",
    "# Initial population\n",
    "population = np.array([chromosome(n) for _ in range(pop_size)])\n",
    "\n",
    "# Get initial elite population\n",
    "elite = Select_elite_population(population)\n",
    "\n",
    "iteration=0 \n",
    "Expected_returns=0\n",
    "Expected_risk=1\n",
    "\n",
    "while (Expected_returns < 0.30 or Expected_risk > 0.02):#and iteration <= 300\n",
    "    print('Iteration:',iteration)\n",
    "    population = next_generation(100,elite,Heuristic_crossover)\n",
    "    elite = Select_elite_population(population)\n",
    "    Expected_returns=mean_portfolio_return(elite[0])\n",
    "    Expected_risk=var_portfolio_return(elite[0])\n",
    "    print('Expected returns of {} with risk of {}\\n'.format(Expected_returns,Expected_risk))\n",
    "    iteration+=1\n",
    "print('\\n\\n=====================================================\\nPortfolio of stocks after all the iterations:\\n')\n",
    "[print(hist_stock_returns.columns[i],':',elite[0][i]) for i in list(range(6))]\n",
    "\n",
    "print('\\nExpected returns of {} with risk of {}\\n'.format(Expected_returns,Expected_risk))"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}