01_Greedy_Gausian_Segmentation(GSS).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Regime Model Greedy Gaussian Segmentation of Multivariate Time Series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "import time\n",
    "import math\n",
    "import random\n",
    "import multiprocessing\n",
    "\n",
    "\n",
    "from itertools import *\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from datetime import datetime\n",
    "from sys import platform as _platform\n",
    "\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.pyplot import cm\n",
    "from matplotlib.dates import date2num\n",
    "plt.rcParams[\"figure.figsize\"] = (12, 8) # (width, height)\n",
    "\n",
    "from utils.index_data import index_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_setting = {\n",
    "    'start' : '1992-01-01',\n",
    "    'end'   : '2021-06-30',\n",
    "    'rebal_period':'1M'\n",
    "}\n",
    "\n",
    "data = index_data(**data_setting)\n",
    "return_df = data.index_data_loading()\n",
    "return_df = return_df.T\n",
    "_return_df = np.array(return_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Find K breakpoints on the data at a specific lambda\n",
    "#Returns: The K breakpoints, along with all intermediate breakpoints (for k < K) and their corresponding\n",
    "#   covariance-regularized maximum likelihoods\n",
    "def GGS(data, Kmax, lamb, features = [], verbose = False):\n",
    "    data = data.T\n",
    "    #Select the desired features\n",
    "    if (features == []):\n",
    "        features = range(data.shape[1])\n",
    "    data = data[:,features]\n",
    "    m,n = data.shape\n",
    "\n",
    "    #Initialize breakpoints\n",
    "    breaks = [0,m+1]\n",
    "    breakPoints = [breaks[:]]\n",
    "    plotPoints = [calculateLikelihood(data, breaks,lamb)]\n",
    "\n",
    "    #Start GGS Algorithm\n",
    "    for z in range(Kmax):\n",
    "        numBreaks = z+1\n",
    "        newInd = -1\n",
    "        newVal = +1\n",
    "        #For each segment, find breakpoint and increase in LL\n",
    "        for i in range(numBreaks):\n",
    "            tempData = data[breaks[i]:breaks[i+1], :]\n",
    "            ind, val = addBreak(tempData, lamb)\n",
    "            if(val < newVal):\n",
    "                newInd = ind + breaks[i]\n",
    "                newVal = val\n",
    "\n",
    "        #Check if our algorithm is finished\n",
    "        if(newVal == 0):\n",
    "            print(\"We are done adding breakpoints!\")\n",
    "            print(breaks)\n",
    "            return breaks, plotPoints\n",
    "\n",
    "        #Add new breakpoint\n",
    "        breaks.append(newInd)\n",
    "        breaks.sort()\n",
    "        if (verbose == True):\n",
    "            print(\"Breakpoint occurs at sample number: \", newInd, \", LL = \",  newVal)\n",
    "            print(len(breaks) - 2, breaks)\n",
    "\n",
    "        #Adjust current locations of the breakpoints\n",
    "        breaks = adjustBreaks(data,breaks,[newInd],lamb,verbose)[:]\n",
    "\n",
    "        #Calculate likelihood\n",
    "        ll = calculateLikelihood(data,breaks,lamb)\n",
    "        breakPoints.append(breaks[:])\n",
    "        plotPoints.append(ll)\n",
    "\n",
    "    return breakPoints, plotPoints\n",
    "\n",
    "#Run cross-validation up to Kmax for a set of lambdas\n",
    "#Return: train and test set likelihood for every K, lambda\n",
    "def GGSCrossVal(data, Kmax=25, lambList = [0.1, 1, 10], features = [], verbose = False):\n",
    "    data = data.T\n",
    "    if (features == []):\n",
    "        features = range(data.shape[1])\n",
    "    data = data[:,features]\n",
    "    origSize, n = data.shape\n",
    "\n",
    "    np.random.seed(0)\n",
    "    ordering = range(origSize)\n",
    "    random.shuffle(ordering)\n",
    "\n",
    "    trainTestResults = []\n",
    "\n",
    "    #For each lambda, run the 10 folds in parallel\n",
    "    numProcesses = min(multiprocessing.cpu_count(),10 )\n",
    "    pool = multiprocessing.Pool(processes = numProcesses)\n",
    "    for lamb in lambList:\n",
    "        mseList = []\n",
    "        trainList = []\n",
    "        returnList = pool.map(multi_run_wrapper, [(0,data, Kmax, lamb, verbose, origSize, n, ordering),\n",
    "            (1,data, Kmax, lamb, verbose, origSize, n, ordering),\n",
    "            (2,data, Kmax, lamb, verbose, origSize, n, ordering),\n",
    "            (3,data, Kmax, lamb, verbose, origSize, n, ordering),\n",
    "            (4,data, Kmax, lamb, verbose, origSize, n, ordering),\n",
    "            (5,data, Kmax, lamb, verbose, origSize, n, ordering),\n",
    "            (6,data, Kmax, lamb, verbose, origSize, n, ordering),\n",
    "            (7,data, Kmax, lamb, verbose, origSize, n, ordering),\n",
    "            (8,data, Kmax, lamb, verbose, origSize, n, ordering),\n",
    "            (9,data, Kmax, lamb, verbose, origSize, n, ordering)])\n",
    "\n",
    "        #Accumulate results\n",
    "        for i in range(10):\n",
    "            for j in returnList[i][0]:\n",
    "                mseList.append(j)\n",
    "            for j in returnList[i][1]:\n",
    "                trainList.append(j)\n",
    "\n",
    "        #Get average of the 10 folds\n",
    "        plotVals = map(list, zip(*mseList))\n",
    "        maxBreaks = max(plotVals[0])+1\n",
    "        testAvg = []\n",
    "        for i in range(maxBreaks):\n",
    "            num = 0\n",
    "            runsum = 0\n",
    "            for j in range(len(plotVals[0])):\n",
    "                if (plotVals[0][j] == i):\n",
    "                    runsum = runsum + plotVals[1][j]\n",
    "                    num = num + 1\n",
    "            testAvg.append(float(runsum)/num)\n",
    "        plotVals2 = map(list, zip(*trainList))\n",
    "        trainAvg = []\n",
    "        for i in range(maxBreaks):\n",
    "            num = 0\n",
    "            runsum = 0\n",
    "            for j in range(len(plotVals2[0])):\n",
    "                if (plotVals[0][j] == i):\n",
    "                    runsum = runsum + plotVals2[1][j]\n",
    "                    num = num + 1\n",
    "            trainAvg.append(float(runsum)/num)\n",
    "\n",
    "        #Combine results for all lambdas into one list and return that\n",
    "        trainTestResults.append((lamb, (trainAvg, testAvg)))\n",
    "\n",
    "    return trainTestResults\n",
    "\n",
    "\n",
    "#Find and return the means/regularized covariance of each segment for a given set of breakpoints\n",
    "def GGSMeanCov(data, breakpoints, lamb, features = [], verbose = False):\n",
    "    data = data.T\n",
    "    #Select the desired features\n",
    "    if (features == []):\n",
    "        features = range(data.shape[1])\n",
    "    data = data[:,features]\n",
    "    m,n = data.shape\n",
    "\n",
    "    numSegments = len(breakpoints) - 1\n",
    "    mean_covs = []\n",
    "    for i in range(numSegments):\n",
    "\n",
    "        #Get mean and regularized covariance of current segment\n",
    "        tempData = data[breakpoints[i]:breakpoints[i+1],:]\n",
    "        m,n = tempData.shape\n",
    "        empMean = np.mean(tempData, axis=0)\n",
    "        empCov = np.cov(tempData.T,bias = True)\n",
    "        regularizedCov = empCov + float(lamb)*np.identity(n)/m\n",
    "\n",
    "        mean_covs.append((empMean, regularizedCov))\n",
    "\n",
    "    return mean_covs\n",
    "\n",
    "\n",
    "#HELPER FUNCTIONS\n",
    "def calculateLikelihood(data, breaks,lamb):\n",
    "    ll = 0\n",
    "    for i in range(len(breaks) - 1):\n",
    "        tempData = data[breaks[i]:breaks[i+1],:]\n",
    "        m,n = tempData.shape\n",
    "        empCov = np.cov(tempData.T,bias = True)\n",
    "        ll = ll - (m*np.linalg.slogdet(empCov + float(lamb)*np.identity(n)/m)[1] - float(lamb) * np.trace(np.linalg.inv(empCov + float(lamb)*np.identity(n)/m)))\n",
    "    return ll\n",
    "\n",
    "def addBreak(data, lamb):\n",
    "    #Initialize parameters\n",
    "    m,n = data.shape\n",
    "    origMean = np.mean(data, axis=0)\n",
    "    origCov = np.cov(data.T,bias = True)\n",
    "    origLL = m*np.linalg.slogdet(origCov + float(lamb)*np.identity(n)/m)[1] - float(lamb) * np.trace(np.linalg.inv(origCov + float(lamb)*np.identity(n)/m))\n",
    "    totSum = m*(origCov+np.outer(origMean,origMean))\n",
    "    muLeft = data[0,:]/n\n",
    "    muRight = (m * origMean - data[0,:])/(m-1)\n",
    "    runSum = np.outer(data[0,:],data[0,:])\n",
    "    #Loop through all samples, find point where breaking the segment would have the largest LL increase\n",
    "    minLL = origLL\n",
    "    minInd = 0\n",
    "    for i in range(2,m-1):\n",
    "        #Update parameters\n",
    "        runSum = runSum + np.outer(data[i-1,:],data[i-1,:])\n",
    "        muLeft = ((i-1)*muLeft + data[i-1,:])/(i)\n",
    "        muRight = ((m-i+1) * muRight - data[i-1,:])/(m-i)\n",
    "        sigLeft = runSum/(i) - np.outer(muLeft, muLeft)\n",
    "        sigRight = (totSum - runSum)/(m-i) - np.outer(muRight,muRight)\n",
    "\n",
    "        #Compute Cholesky, LogDet, and Trace\n",
    "        Lleft = np.linalg.cholesky(sigLeft + float(lamb)*np.identity(n)/i)\n",
    "        Lright = np.linalg.cholesky(sigRight + float(lamb)*np.identity(n)/(m-i))\n",
    "        llLeft = 2*sum(map(math.log, np.diag(Lleft)))\n",
    "        llRight = 2*sum(map(math.log, np.diag(Lright)))\n",
    "        (trLeft, trRight) = (0,0)\n",
    "        if(lamb > 0):\n",
    "            trLeft = math.pow(np.linalg.norm(np.linalg.inv(Lleft)),2)\n",
    "            trRight = math.pow(np.linalg.norm(np.linalg.inv(Lright)),2)\n",
    "        LL = i*llLeft - float(lamb)*trLeft + (m-i)*llRight - float(lamb)*trRight\n",
    "        #Keep track of the best point so far\n",
    "        if(LL < minLL):\n",
    "            minLL = LL\n",
    "            minInd = i\n",
    "    #Return break, increase in LL\n",
    "    return (minInd,minLL-origLL)\n",
    "\n",
    "def adjustBreaks(data, breakpoints, newInd, lamb = 0, verbose = False, maxShuffles = 250):\n",
    "    bp = breakpoints[:]\n",
    "    random.seed(0)\n",
    "    #Just one breakpoint, no need to adjust anything\n",
    "    if (len(bp) == 3):\n",
    "        return bp\n",
    "    #Keep track of what breakpoints have changed, so that we don't have to adjust ones which we know are constant\n",
    "    lastPass = dict()\n",
    "    thisPass = dict()\n",
    "    for b in bp:\n",
    "        thisPass[b] = 0\n",
    "    for i in newInd:\n",
    "        thisPass[i] = 1\n",
    "    for z in range(maxShuffles):\n",
    "        lastPass = dict(thisPass)\n",
    "        thisPass = dict()\n",
    "        for b in bp:\n",
    "            thisPass[b] = 0\n",
    "        switchAny = False\n",
    "        ordering = range(1,len(bp) - 1)\n",
    "\n",
    "        random.sample(ordering, k=len(ordering))\n",
    "        for i in ordering:\n",
    "            #Check if we need to adjust it\n",
    "            if(lastPass[bp[i-1]] == 1 or lastPass[bp[i+1]] == 1 or thisPass[bp[i-1]] == 1 or thisPass[bp[i+1]] == 1):\n",
    "                tempData = data[bp[i-1]:bp[i+1], :]\n",
    "                ind, val = addBreak(tempData, lamb)\n",
    "                if (bp[i] != ind + bp[i-1] and val != 0):\n",
    "                    lastPass[ind+bp[i-1]] = lastPass[bp[i]]\n",
    "                    del lastPass[bp[i]]\n",
    "                    del thisPass[bp[i]]\n",
    "                    thisPass[ind+bp[i-1]] = 1\n",
    "                    if (verbose == True):\n",
    "                        print(\"Moving\", bp[i], \"to\", ind+bp[i-1], \"length = \", tempData.shape[0], ind)\n",
    "                    bp[i] = ind + bp[i-1]\n",
    "                    switchAny = True\n",
    "        if (switchAny == False):\n",
    "            return bp\n",
    "    return bp\n",
    "\n",
    "def multi_run_wrapper(args):\n",
    "    return oneFold(*args)\n",
    "def oneFold(fold, data, breakpoints, lamb, verbose, origSize, n, ordering):\n",
    "    # Remove 10% of data for test set\n",
    "    mseList = []\n",
    "    trainList = []\n",
    "    testSet = np.sort(ordering[(fold)*origSize/10:(fold+1)*origSize/10])\n",
    "    mask = np.ones(origSize, dtype=bool)\n",
    "    mask[testSet] = False\n",
    "    trainData = data[mask,:]\n",
    "    # Solve for test and train error\n",
    "    testSize = len(testSet)\n",
    "    trainSize = origSize - testSize\n",
    "    bp = GGS(trainData.T, breakpoints, lamb, [], verbose)[0]\n",
    "    for z in bp:\n",
    "        i = z\n",
    "        (mse, currBreak) = (0, 1)\n",
    "        temp = trainData[0:i[1]]\n",
    "        empMean = np.mean(temp, axis=0)\n",
    "        empCov = np.cov(temp.T,bias = True) + float(lamb)*np.identity(n)/temp.shape[0]\n",
    "        invCov = np.linalg.inv(empCov)\n",
    "        #Calculate test error\n",
    "        for j in range(testSize):\n",
    "            #Find which break it's in\n",
    "            adj = testSet[j] - j\n",
    "            cb = max(sum(1 for k in i if k < adj),1)\n",
    "            if (currBreak != cb):\n",
    "                currBreak = cb\n",
    "                temp = trainData[i[currBreak-1]:i[currBreak]]\n",
    "                empMean = np.mean(temp, axis=0)\n",
    "                empCov = np.cov(temp.T,bias = True) + float(lamb)*np.identity(n)/temp.shape[0]\n",
    "                invCov = np.linalg.inv(empCov)\n",
    "            #Compute likelihood\n",
    "            ldet = 0.5*np.linalg.slogdet(invCov)[1]\n",
    "            ll = ldet - 0.5*(data[testSet[j]] - empMean).dot(invCov).dot((data[testSet[j]] - empMean)) - n*math.log(2*math.pi)/2\n",
    "            mse = mse+ll\n",
    "        mseList.append((len(i)-2, mse/testSize))\n",
    "        #Calculate training error\n",
    "        tErr = 0\n",
    "        currBreak = 1\n",
    "        temp = trainData[0:i[1]]\n",
    "        empMean = np.mean(temp, axis=0)\n",
    "        empCov = np.cov(temp.T,bias = True) + float(lamb)*np.identity(n)/temp.shape[0]\n",
    "        invCov = np.linalg.inv(empCov)\n",
    "        for j in range(1,trainSize):\n",
    "            if(j in i):\n",
    "                currBreak = currBreak + 1\n",
    "                temp = trainData[i[currBreak-1]:i[currBreak]]\n",
    "                empMean = np.mean(temp, axis=0)\n",
    "                empCov = np.cov(temp.T,bias = True) + float(lamb)*np.identity(n)/temp.shape[0]\n",
    "                invCov = np.linalg.inv(empCov)\n",
    "            #Compute likelihood\n",
    "            ldet = 0.5*np.linalg.slogdet(invCov)[1]\n",
    "            ll = ldet - 0.5*(trainData[j] - empMean).dot(invCov).dot((trainData[j] - empMean)) - n*math.log(2*math.pi)/2\n",
    "            tErr = tErr+ll\n",
    "        trainList.append((len(i)-2, tErr/trainSize))\n",
    "    return mseList, trainList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# selected features' index of return_df\n",
    "feats = [1,2,5,6,9,12]\n",
    "# msci_world\n",
    "# msci_emerging\n",
    "# bb_world_agg\n",
    "# bb_corp_hy\n",
    "# us_short_treasury"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "bps, objectives = GGS(_return_df, Kmax = 10, lamb = 1e-4, features = feats)\n",
    "bp10 = bps[10] # Get breakpoints for K = 10\n",
    "bp10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "meancovs = GGSMeanCov(_return_df, breakpoints = bp10, lamb = 1e-4, features = feats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Breakpoints are at [[0, 355], [0, 97, 355], [0, 97, 218, 355], [0, 97, 201, 218, 355], [0, 97, 139, 186, 218, 355], [0, 97, 139, 186, 218, 322, 355], [0, 97, 139, 186, 203, 218, 322, 355], [0, 80, 97, 139, 186, 203, 218, 322, 355], [0, 80, 97, 139, 186, 203, 218, 248, 324, 355], [0, 80, 97, 139, 186, 203, 218, 248, 324, 342, 355], [0, 80, 97, 139, 186, 203, 207, 218, 248, 324, 342, 355]]\n",
      "Objectives are [17171.232642634757, 18154.515696158316, 18445.562497417035, 18573.614640196425, 18710.83288723707, 18793.886249939806, 18867.104997447528, 18923.832696898917, 18976.13926494669, 19030.70872594358, 19086.266705174927]\n"
     ]
    }
   ],
   "source": [
    "print(\"Breakpoints are at\", bps)\n",
    "print(\"Objectives are\", objectives)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "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>msci_world_cum</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1992-01-31</th>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1992-02-29</th>\n",
       "      <td>0.979322</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1992-03-31</th>\n",
       "      <td>0.962324</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1992-04-30</th>\n",
       "      <td>0.898778</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1992-05-31</th>\n",
       "      <td>0.923565</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-02-28</th>\n",
       "      <td>5.039375</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-03-31</th>\n",
       "      <td>5.199679</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-04-30</th>\n",
       "      <td>5.305197</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-05-31</th>\n",
       "      <td>5.507827</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-06-30</th>\n",
       "      <td>5.570121</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>354 rows × 1 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "            msci_world_cum\n",
       "1992-01-31        1.000000\n",
       "1992-02-29        0.979322\n",
       "1992-03-31        0.962324\n",
       "1992-04-30        0.898778\n",
       "1992-05-31        0.923565\n",
       "...                    ...\n",
       "2021-02-28        5.039375\n",
       "2021-03-31        5.199679\n",
       "2021-04-30        5.305197\n",
       "2021-05-31        5.507827\n",
       "2021-06-30        5.570121\n",
       "\n",
       "[354 rows x 1 columns]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = index_data(**data_setting)\n",
    "world_index = data.index_cum_data_loading()\n",
    "world_index = world_index[['msci_world']]\n",
    "world_index.columns = ['msci_world_cum']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 80, 97, 139, 186, 203, 207, 218, 248, 324, 342, 355]\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>msci_world_cum</th>\n",
       "      <th>regime</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1992-01-31</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1992-02-29</td>\n",
       "      <td>0.979322</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1992-03-31</td>\n",
       "      <td>0.962324</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1992-04-30</td>\n",
       "      <td>0.898778</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1992-05-31</td>\n",
       "      <td>0.923565</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>349</th>\n",
       "      <td>2021-02-28</td>\n",
       "      <td>5.039375</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>350</th>\n",
       "      <td>2021-03-31</td>\n",
       "      <td>5.199679</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>351</th>\n",
       "      <td>2021-04-30</td>\n",
       "      <td>5.305197</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>352</th>\n",
       "      <td>2021-05-31</td>\n",
       "      <td>5.507827</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>353</th>\n",
       "      <td>2021-06-30</td>\n",
       "      <td>5.570121</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>354 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "          Date  msci_world_cum regime\n",
       "0   1992-01-31        1.000000      1\n",
       "1   1992-02-29        0.979322      1\n",
       "2   1992-03-31        0.962324      1\n",
       "3   1992-04-30        0.898778      1\n",
       "4   1992-05-31        0.923565      1\n",
       "..         ...             ...    ...\n",
       "349 2021-02-28        5.039375     11\n",
       "350 2021-03-31        5.199679     11\n",
       "351 2021-04-30        5.305197     11\n",
       "352 2021-05-31        5.507827     11\n",
       "353 2021-06-30        5.570121     11\n",
       "\n",
       "[354 rows x 3 columns]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(bp10)\n",
    "world_index['regime'] = ''\n",
    "i = 0\n",
    "prev_bp = 0\n",
    "for bp in bp10:\n",
    "    world_index['regime'].iloc[prev_bp: bp] = i\n",
    "    prev_bp = bp\n",
    "    i = i + 1\n",
    "\n",
    "world_index = world_index.reset_index()\n",
    "world_index.columns = ['Date','msci_world_cum','regime']\n",
    "world_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<seaborn.axisgrid.FacetGrid at 0x7f4f245bd610>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1180.59x864 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_style('whitegrid')\n",
    "colors = cm.rainbow(np.linspace(0, 1, len(bp10)))\n",
    "order = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]\n",
    "fg = sns.FacetGrid(data=world_index, hue='regime', hue_order=order,\n",
    "                   palette=colors, aspect=1.31, size=12)\n",
    "fg.map(plt.scatter, 'Date', 'msci_world_cum', alpha=0.8).add_legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "7e41e0e2f6624f82749fefd03121b780fee668496701b39acf86fcddf67ffcea"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}