alinaselega/PELT_debug.ipynb

## PELT_debug.ipynb
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook is for checking the pruning condition of PELT as written in their paper. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reproducibility:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "224e8f2\r\n"
     ]
    }
   ],
   "source": [
    "! git rev-parse --short HEAD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import optimal_segmentation as opt\n",
    "import data\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import math\n",
    "import time\n",
    "plt.style.use(\"ggplot\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modify below `opt_segm_max` to not have extra parameters not needed for toy Gaussian data, e.g. `n_obs`, `variances` etc. This function, as before in my code, *maximises* the total segmentation cost and sets the cost as twice log-likelihood."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Optimal segmentation function adapted to multiple observations\n",
    "def opt_segm_max(Y, penalty_param, min_seg_len, score_function):\n",
    "    \"\"\"\n",
    "    Generate partitioning of data using optimal segmentation \n",
    "    Args:\n",
    "    y (array of floats): data\n",
    "    p (integer): number of parameters added per changepoint (BIC penalty)\n",
    "    k (integer): minimum considered segment length \n",
    "    score_function (function): segment scoring function\n",
    "    Return:\n",
    "    List containing optimal segmentation of the data\n",
    "    \"\"\"\n",
    "\n",
    "    # Number of dimensions (genes)\n",
    "    n = Y.shape[1]\n",
    "\n",
    "    # BIC: p*log(n)*m for\n",
    "    # p - number of parameters added per changepoint\n",
    "    # m - number of changepoints\n",
    "    penalty = penalty_param * np.log(n)\n",
    "\n",
    "    # Array containing best score for subpartition of each size\n",
    "    # Initialise at 0; store -inf in order to compare with logliks\n",
    "    f_scores = np.zeros(n+1)\n",
    "    f_scores[:] = -math.inf\n",
    "    f_scores[0] = penalty\n",
    "\n",
    "    # List of changepoints\n",
    "    cp = {}\n",
    "    cp[0] = [np.nan]\n",
    "\n",
    "    # tau_star is the index until which we are scoring\n",
    "    for tau_star in range(1, n+1):\n",
    "        # candidate changepoint tau\n",
    "        for tau in range(tau_star):\n",
    "           \n",
    "            # Slice out the data to the right of tau\n",
    "            data_slice = Y[:, tau:tau_star]\n",
    "\n",
    "            # Segments of length < k are not considered\n",
    "            if (data_slice.shape[1] < min_seg_len):\n",
    "                continue\n",
    "           \n",
    "            r_score = 2 *score_function(data_slice)\n",
    "            candidate_score = f_scores[tau] + r_score - penalty\n",
    "           \n",
    "            # Update f_scores if candidate score is larger than before\n",
    "            if (candidate_score > f_scores[tau_star]):\n",
    "                f_scores[tau_star] = candidate_score\n",
    "                cp[tau_star] = [tau] + cp[tau]\n",
    "\n",
    "    return cp, f_scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is Iain's implementation modified by me. This also maximises the total cost. In addition, it appears that `K` from the PELT paper here is `K=0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def inefficient_pelt_max(Y, penalty_param, min_seg_len, score_function):\n",
    "    \"\"\"\n",
    "    Generate partitioning of data using PELT method\n",
    "    Args:\n",
    "        y (array of floats): data\n",
    "        p (integer): number of parameters added per changepoint (BIC penalty)\n",
    "        k (integer): minimum considered segment length \n",
    "        score_function (function): segment scoring function\n",
    "    \n",
    "    Return:\n",
    "        List containing optimal segmentation of the data\n",
    "    \"\"\"\n",
    "    # Number of datapoints as dimensions \n",
    "    n = Y.shape[1] \n",
    "\n",
    "    # BIC: p*log(n)*m for\n",
    "    # p - number of parameters added per changepoint\n",
    "    # m - number of changepoints\n",
    "    penalty = penalty_param * np.log(n)\n",
    "    \n",
    "    # Matrix which contains scores for all subpartitions\n",
    "    sp_scores = np.zeros((n, n))\n",
    "    sp_scores[:] = np.nan\n",
    "\n",
    "    # Array containing maximum score (best likelihood) for subpartition of each size\n",
    "    max_sp_scores = np.zeros(n)\n",
    "\n",
    "    # Set of potential changepoints to exclude\n",
    "    prune_set = []\n",
    "\n",
    "    # sp_len is size of subproblem\n",
    "    for sp_len in range(n):\n",
    "        for last_cp in range(sp_len + 1):\n",
    "            # Slice out the data for this subproblem starting from last changepoint\n",
    "            data_slice = Y[:, last_cp:sp_len + 1]\n",
    "\n",
    "            # Check if last_cp has been pruned\n",
    "            if last_cp in prune_set:\n",
    "                sp_scores[sp_len, last_cp] = -math.inf\n",
    "                continue\n",
    "\n",
    "            # Segments of length <k are not considered\n",
    "            if (data_slice.shape[1] < min_seg_len):\n",
    "                sp_scores[sp_len, last_cp] = -math.inf\n",
    "                continue\n",
    "            \n",
    "            # Compute the score of the segment from last changepoint till end of \n",
    "            # subproblem\n",
    "            r_score = 2 * score_function(data_slice)\n",
    "\n",
    "            # If we are not placing a changepoint (last_cp == 0), \n",
    "            # add score of the whole block\n",
    "            if last_cp == 0:\n",
    "                sp_scores[sp_len, last_cp] = r_score\n",
    "            else:\n",
    "                # Otherwise, look up the best score of the subpartition\n",
    "                l_score = max_sp_scores[last_cp-1]\n",
    "                # The total score of the segment is the sum of left and right\n",
    "                # scores minus the penalty\n",
    "                sp_scores[sp_len, last_cp] = l_score + r_score - penalty\n",
    "        \n",
    "        # Store the maximum score for this subproblem\n",
    "        max_sp_scores[sp_len] = np.nanmax(sp_scores[sp_len,:])\n",
    "\n",
    "        # Check all changepoints for prune condition\n",
    "        for cp in range(sp_len):\n",
    "            if sp_scores[sp_len, cp] == -math.inf:\n",
    "                continue\n",
    "            # This is the pruning condition    \n",
    "            if sp_scores[sp_len, cp] + penalty < max_sp_scores[sp_len]:\n",
    "                prune_set.append(cp)\n",
    "\n",
    "    chpts, ll = recover_changepoints(sp_scores)\n",
    "    return chpts, ll\n",
    "\n",
    "## This function recovers changepoints from the inefficient PELT\n",
    "## implementation. Ported from the notebook to check that implementation.\n",
    "def recover_changepoints(score_matrix):\n",
    "    \"\"\"\n",
    "    Recover the segmentation resulting in the greatest score under the BIC.\n",
    "    \n",
    "    Args:\n",
    "        score_matrix (2D matrix of floats): Log likelihoods of subsegments\n",
    "    Returns: \n",
    "        Changepoints corresponding to optimal segmentation\n",
    "    \"\"\"\n",
    "    opt_cps = [np.argmax(score_matrix[-1])]\n",
    "    ll = score_matrix[-1, opt_cps]\n",
    "    while opt_cps[-1] != 0:\n",
    "        optimal_cp = np.nanargmax((score_matrix[opt_cps[-1] - 1]))\n",
    "        opt_cps.append(optimal_cp)\n",
    "    return opt_cps, ll"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the modified PELT function; again maximising the cost and using `K=0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pelt_max(Y, penalty_param, min_seg_len, score_function):\n",
    "  \n",
    "    \"\"\"\n",
    "    Generate partitioning of data using PELT method\n",
    "    Args:\n",
    "        y (array of floats): data\n",
    "        p (integer): number of parameters added per changepoint (BIC penalty)\n",
    "        k (integer): minimum considered segment length \n",
    "        score_function (function): segment scoring function\n",
    "    \n",
    "    Return:\n",
    "        List containing optimal segmentation of the data\n",
    "    \"\"\"\n",
    "    # Number of datapoints\n",
    "    n = Y.shape[1] \n",
    "\n",
    "    # BIC: p*log(n)*m for\n",
    "    # p - number of parameters added per changepoint\n",
    "    # m - number of changepoints\n",
    "    penalty = penalty_param * np.log(n)\n",
    "   \n",
    "    # Array containing maximum score (best likelihood) for subpartition of each size\n",
    "    f_scores = np.zeros(n+1)\n",
    "    f_scores[:] = -math.inf\n",
    "    f_scores[0] = penalty\n",
    " \n",
    "    # List of changepoints\n",
    "    cp = {}\n",
    "    cp[0] = [np.nan]\n",
    "    \n",
    "    # Pruned changepoints\n",
    "    pruned = []\n",
    "    avail_cps = [0]\n",
    "    r_scores = np.zeros(n)\n",
    "    r_scores[:] = -math.inf\n",
    "    \n",
    "    K = 0\n",
    "    \n",
    "    # tau_star is the index until which we are scoring\n",
    "    for tau_star in range(1, n+1):\n",
    "        for tau in avail_cps:\n",
    "            # Slice out the data to the right\n",
    "            data_slice = Y[:, tau:tau_star]\n",
    "            \n",
    "            # Segments of length < k are not considered\n",
    "            if (data_slice.shape[1] < min_seg_len):\n",
    "                continue\n",
    "           \n",
    "            r_scores[tau] = 2 * score_function(data_slice)\n",
    "            candidate_score = f_scores[tau] + r_scores[tau] - penalty\n",
    "           \n",
    "            # Update f_scores if candidate score is larger than before\n",
    "            if (candidate_score > f_scores[tau_star]):\n",
    "                f_scores[tau_star] = candidate_score\n",
    "                cp[tau_star] = [tau] + cp[tau]\n",
    "                \n",
    "        pruned = []\n",
    "        for chp in avail_cps:\n",
    "            if not np.isinf(r_scores[chp]):\n",
    "                if f_scores[chp] + r_scores[chp] + K < f_scores[tau_star]:\n",
    "                    pruned = pruned + [chp]\n",
    "        \n",
    "        avail_cps = np.setdiff1d(avail_cps, np.array(pruned))\n",
    "        avail_cps = np.append(avail_cps, tau_star)\n",
    "    \n",
    "    return cp, f_scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modify this normal likelihood to allow for a single datapoint by adding a small number to variance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def norm_likelihood(data):\n",
    "    \"\"\"\n",
    "    Compute log-likelihood under normal distribution for multiple samples\n",
    "    Args:\n",
    "        data (matrix): data, samples x genes\n",
    "    Return:\n",
    "        Log-likelihood of the data under the Gaussian distribution with ML estimates of parameters\n",
    "    \"\"\"\n",
    "    # Number of genes\n",
    "    G = data.shape[1]\n",
    "    # Number of samples (cells)\n",
    "    N = data.shape[0]\n",
    "    mean = np.mean(data, axis=1, keepdims=True)\n",
    "    variance = np.var(data, axis=1, keepdims = True) #+ 1e-6\n",
    "        \n",
    "    # This is (y_n - mean_n)**2, Nx1 vector\n",
    "    squared_term = np.sum((data - mean)**2, axis=1, keepdims = True)\n",
    "\n",
    "    log_p_yn = -G/2.0 * np.log(2.0 * np.pi) - G/2.0 * np.log(variance) - 0.5 * (1.0 / variance) * squared_term \n",
    "    pdf = np.sum(log_p_yn)\n",
    "    return pdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import norm\n",
    "\n",
    "# Validate Normal loglik\n",
    "def norm_lik_scipy(data):\n",
    "    mean = np.mean(data, axis=1)\n",
    "    variance = np.var(data, axis=1)\n",
    "    return np.sum(norm.logpdf(data, mean, np.sqrt(variance)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate toy data from switching Gaussians."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f567616c358>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "G = 150\n",
    "N = 1\n",
    "# This generates three Gaussians\n",
    "Y = opt.generate_gaussian_data(G=G, N=1, plot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-218.077489237\n",
      "-218.077489237\n"
     ]
    }
   ],
   "source": [
    "print(norm_likelihood(Y[:,0:150]))\n",
    "print(norm_lik_scipy(Y[:,0:150]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run `opt_segm_max`. Let's use a small `min_seg_len`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Method: <function opt_segm_max at 0x7f56761bd8c8>, time: 10.799472332000732\n",
      " Found changepoints: [150, 300, 446], Loglik: -1126.6793436724063\n"
     ]
    }
   ],
   "source": [
    "method = opt_segm_max\n",
    "penalty_param = 3\n",
    "min_seg_len = 2\n",
    "start = time.time()\n",
    "cps, f_scores = method(Y, penalty_param, min_seg_len, norm_likelihood)\n",
    "end = time.time()\n",
    "print(f\" Method: {method}, time: {end-start}\")\n",
    "cps = cps[Y.shape[1]][::-1]\n",
    "print(f\" Found changepoints: {cps[2:]}, Loglik: {f_scores[Y.shape[1]]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A note: a larger `min_seg_len` removes the \"spurious\" changepoint from the solution. The new log-likelihood is slightly larger."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Method: <function opt_segm_max at 0x7f56761bd8c8>, time: 10.437129497528076\n",
      " Found changepoints: [150, 300], Loglik: -1132.166584203548\n"
     ]
    }
   ],
   "source": [
    "method = opt_segm_max\n",
    "penalty_param = 3\n",
    "min_seg_len = 5\n",
    "start = time.time()\n",
    "cps, f_scores = method(Y, penalty_param, min_seg_len, norm_likelihood)\n",
    "end = time.time()\n",
    "print(f\" Method: {method}, time: {end-start}\")\n",
    "cps = cps[Y.shape[1]][::-1]\n",
    "print(f\" Found changepoints: {cps[2:]}, Loglik: {f_scores[Y.shape[1]]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run `inefficient_pelt_max`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Method: <function inefficient_pelt_max at 0x7f569c6aa400>, time: 3.733776569366455\n",
      " Found changepoints: [150, 300, 446], Loglik: [-1126.67934367]\n"
     ]
    }
   ],
   "source": [
    "method = inefficient_pelt_max\n",
    "penalty_param = 3\n",
    "min_seg_len = 2\n",
    "start = time.time()\n",
    "cps, f_scores = method(Y, penalty_param, min_seg_len, norm_likelihood)\n",
    "end = time.time()\n",
    "print(f\" Method: {method}, time: {end-start}\")\n",
    "print(f\" Found changepoints: {cps[:-1][::-1]}, Loglik: {f_scores}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run `pelt_max` (with `K = 0`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Method: <function pelt_max at 0x7f56794d8840>, time: 3.322131633758545\n",
      " Found changepoints: [150, 300, 446], Loglik: -1126.6793436724063\n"
     ]
    }
   ],
   "source": [
    "method = pelt_max\n",
    "penalty_param = 3\n",
    "min_seg_len = 2\n",
    "start = time.time()\n",
    "cps, f_scores = method(Y, penalty_param, min_seg_len, norm_likelihood)\n",
    "end = time.time()\n",
    "print(f\" Method: {method}, time: {end-start}\")\n",
    "cps = cps[Y.shape[1]][::-1]\n",
    "print(f\" Found changepoints: {cps[2:]}, Loglik: {f_scores[Y.shape[1]]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now define `opt_segm_min`, which *minimises* total segmentation cost (following the PELT paper) by reversing the signs of cost, penalty, and comparisons.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Optimal segmentation function adapted to multiple observations\n",
    "def opt_segm_min(Y, penalty_param, min_seg_len, score_function):\n",
    "    \"\"\"\n",
    "    Generate partitioning of data using optimal segmentation \n",
    "    Args:\n",
    "    y (array of floats): data\n",
    "    p (integer): number of parameters added per changepoint (BIC penalty)\n",
    "    k (integer): minimum considered segment length \n",
    "    score_function (function): segment scoring function\n",
    "    Return:\n",
    "    List containing optimal segmentation of the data\n",
    "    \"\"\"\n",
    "\n",
    "    # Number of dimensions (genes)\n",
    "    n = Y.shape[1]\n",
    "\n",
    "    # BIC: p*log(n)*m for\n",
    "    # p - number of parameters added per changepoint\n",
    "    # m - number of changepoints\n",
    "    penalty = penalty_param * np.log(n)\n",
    "\n",
    "    # Array containing best score for subpartition of each size\n",
    "    # Initialise at 0; store -inf in order to compare with logliks\n",
    "    f_scores = np.zeros(n+1)\n",
    "    f_scores[:] = math.inf\n",
    "    f_scores[0] = -penalty\n",
    "\n",
    "    # List of changepoints\n",
    "    cp = {}\n",
    "    cp[0] = [np.nan]\n",
    "\n",
    "    # tau_star is the index until which we are scoring\n",
    "    for tau_star in range(1, n+1):\n",
    "        # candidate changepoint tau\n",
    "        for tau in range(tau_star):\n",
    "           \n",
    "            # Slice out the data to the right of tau\n",
    "            data_slice = Y[:, tau:tau_star]\n",
    "\n",
    "            # Segments of length < k are not considered\n",
    "            if (data_slice.shape[1] < min_seg_len):\n",
    "                continue\n",
    "           \n",
    "            r_score = 2 * (-score_function(data_slice))\n",
    "            candidate_score = f_scores[tau] + r_score + penalty\n",
    "           \n",
    "            # Update f_scores if candidate score is larger than before\n",
    "            if (candidate_score < f_scores[tau_star]):\n",
    "                f_scores[tau_star] = candidate_score\n",
    "                cp[tau_star] = [tau] + cp[tau]\n",
    "\n",
    "    return cp, f_scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run this. The final cost should be the negative cost from `opt_segm_max`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Method: <function opt_segm_min at 0x7f5673e6a730>, time: 11.017191171646118\n",
      " Found changepoints: [150, 300, 446], Loglik: 1126.6793436724063\n"
     ]
    }
   ],
   "source": [
    "method = opt_segm_min\n",
    "penalty_param = 3\n",
    "min_seg_len = 2\n",
    "start = time.time()\n",
    "cps, f_scores = method(Y, penalty_param, min_seg_len, norm_likelihood)\n",
    "end = time.time()\n",
    "print(f\" Method: {method}, time: {end-start}\")\n",
    "cps = cps[Y.shape[1]][::-1]\n",
    "print(f\" Found changepoints: {cps[2:]}, Loglik: {f_scores[Y.shape[1]]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f5673ebc8d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(Y.T)\n",
    "for cp in cps:\n",
    "    plt.axvline(cp, color='blue', linestyle='--')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now define `pelt_min` to minimise the total cost."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pelt_min(Y, penalty_param, min_seg_len, score_function, K):\n",
    "  \n",
    "    \"\"\"\n",
    "    Generate partitioning of data using PELT method\n",
    "    Args:\n",
    "        y (array of floats): data\n",
    "        p (integer): number of parameters added per changepoint (BIC penalty)\n",
    "        k (integer): minimum considered segment length \n",
    "        score_function (function): segment scoring function\n",
    "    \n",
    "    Return:\n",
    "        List containing optimal segmentation of the data\n",
    "    \"\"\"\n",
    "    # Number of datapoints\n",
    "    n = Y.shape[1] \n",
    "\n",
    "    # BIC: p*log(n)*m for\n",
    "    # p - number of parameters added per changepoint\n",
    "    # m - number of changepoints\n",
    "    penalty = penalty_param * np.log(n)\n",
    "   \n",
    "    # Array containing maximum score (best likelihood) for subpartition of each size\n",
    "    f_scores = np.zeros(n+1)\n",
    "    f_scores[:] = math.inf\n",
    "    f_scores[0] = -penalty\n",
    " \n",
    "    # List of changepoints\n",
    "    cp = {}\n",
    "    cp[0] = [np.nan]\n",
    "    \n",
    "    # Pruned changepoints\n",
    "    pruned = []\n",
    "    avail_cps = [0]\n",
    "    r_scores = np.zeros(n)\n",
    "    r_scores[:] = -math.inf\n",
    "    \n",
    "    # tau_star is the index until which we are scoring\n",
    "    for tau_star in range(1, n+1):\n",
    "        #r_scores[:] = 0\n",
    "        for tau in avail_cps:\n",
    "            # Slice out the data to the right\n",
    "            data_slice = Y[:, tau:tau_star]\n",
    "            \n",
    "            # Segments of length < k are not considered\n",
    "            if (data_slice.shape[1] < min_seg_len):\n",
    "                continue\n",
    "           \n",
    "            r_scores[tau] = 2 * (-score_function(data_slice))\n",
    "            candidate_score = f_scores[tau] + r_scores[tau] + penalty\n",
    "           \n",
    "            # Update f_scores if candidate score is smaller than before\n",
    "            if (candidate_score < f_scores[tau_star]):\n",
    "                f_scores[tau_star] = candidate_score\n",
    "                cp[tau_star] = [tau] + cp[tau]\n",
    "                \n",
    "        pruned = []\n",
    "        for chp in avail_cps:\n",
    "            if not np.isinf(r_scores[chp]):\n",
    "                if f_scores[chp] + r_scores[chp] + K > f_scores[tau_star]:\n",
    "                    pruned = pruned + [chp]\n",
    "        \n",
    "        avail_cps = np.setdiff1d(avail_cps, np.array(pruned))\n",
    "        avail_cps = np.append(avail_cps, tau_star)\n",
    "        #print(f\"avail cps: {avail_cps}, {tau_star}, pruned: {pruned}, cps: {cp}\")\n",
    "    return cp, f_scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run `pelt_min` with `K=0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Method: <function pelt_min at 0x7f5673e6a840>, time: 3.6971495151519775\n",
      " Found changepoints: [150, 300, 446], Loglik: 1126.6793436724063\n"
     ]
    }
   ],
   "source": [
    "method = pelt_min\n",
    "penalty_param = 3\n",
    "min_seg_len = 2\n",
    "np.seterr('raise')\n",
    "start = time.time()\n",
    "cps, f_scores = method(Y, penalty_param, min_seg_len, norm_likelihood, K=0)\n",
    "end = time.time()\n",
    "print(f\" Method: {method}, time: {end-start}\")\n",
    "cps = cps[Y.shape[1]][::-1]\n",
    "print(f\" Found changepoints: {cps[2:]}, Loglik: {f_scores[Y.shape[1]]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now run with `K=\\beta`. This finds more changepoints. This is very pronounced with small `min_seg_len`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Method: <function pelt_min at 0x7f5673e6a840>, time: 0.16683173179626465\n",
      " Found changepoints: [33, 150, 171, 173, 246, 256, 258, 300], Loglik: 1193.9101485357069\n"
     ]
    }
   ],
   "source": [
    "method = pelt_min\n",
    "penalty_param = 3\n",
    "min_seg_len = 2\n",
    "beta = penalty_param * np.log(Y.shape[1])\n",
    "start = time.time()\n",
    "cps, f_scores = method(Y, penalty_param, min_seg_len, norm_likelihood, K=beta)\n",
    "end = time.time()\n",
    "print(f\" Method: {method}, time: {end-start}\")\n",
    "cps = cps[Y.shape[1]][::-1]\n",
    "print(f\" Found changepoints: {cps[2:]}, Loglik: {f_scores[Y.shape[1]]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f5673e2acc0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(Y.T)\n",
    "for cp in cps:\n",
    "    plt.axvline(cp, color='blue', linestyle='--')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A note: with larger `min_seg_len`, the best solution is much closer to the optimal one likelihood-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Method: <function pelt_min at 0x7f5673e6a840>, time: 0.16912388801574707\n",
      " Found changepoints: [150, 300, 446], Loglik: 1126.6793436724063\n"
     ]
    }
   ],
   "source": [
    "method = pelt_min\n",
    "penalty_param = 3\n",
    "min_seg_len = 4\n",
    "beta = penalty_param * np.log(Y.shape[1])\n",
    "start = time.time()\n",
    "cps, f_scores = method(Y, penalty_param, min_seg_len, norm_likelihood, K=beta)\n",
    "end = time.time()\n",
    "print(f\" Method: {method}, time: {end-start}\")\n",
    "cps = cps[Y.shape[1]][::-1]\n",
    "print(f\" Found changepoints: {cps[2:]}, Loglik: {f_scores[Y.shape[1]]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we reduce `K`, it prunes fewer changepoints -- and recovers a solution with a better likelihood."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Method: <function pelt_min at 0x7f5673e6a840>, time: 0.15089082717895508\n",
      " Found changepoints: [150, 256, 258, 300], Loglik: 1141.0937915743707\n"
     ]
    }
   ],
   "source": [
    "method = pelt_min\n",
    "penalty_param = 3\n",
    "min_seg_len = 2\n",
    "beta = penalty_param * np.log(Y.shape[1])\n",
    "start = time.time()\n",
    "cps, f_scores = method(Y, penalty_param, min_seg_len, norm_likelihood, K=beta-3)\n",
    "end = time.time()\n",
    "print(f\" Method: {method}, time: {end-start}\")\n",
    "cps = cps[Y.shape[1]][::-1]\n",
    "print(f\" Found changepoints: {cps[2:]}, Loglik: {f_scores[Y.shape[1]]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Defining penalty to be `K=\\beta/2` recovers the optimal solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Method: <function pelt_min at 0x7f5673e6a840>, time: 0.1628892421722412\n",
      " Found changepoints: [150, 300, 446], Loglik: 1126.6793436724063\n"
     ]
    }
   ],
   "source": [
    "method = pelt_min\n",
    "min_seg_len = 2\n",
    "penalty_param = 3\n",
    "beta = penalty_param * np.log(Y.shape[1])\n",
    "start = time.time()\n",
    "cps, f_scores = method(Y, penalty_param, min_seg_len, norm_likelihood, K=beta/2)\n",
    "end = time.time()\n",
    "print(f\" Method: {method}, time: {end-start}\")\n",
    "cps = cps[Y.shape[1]][::-1]\n",
    "print(f\" Found changepoints: {cps[2:]}, Loglik: {f_scores[Y.shape[1]]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusions\n",
    "\n",
    "The conclusion is as follows: when we have `K=\\beta` in the pruning condition, which looks as follows:\n",
    "\n",
    "\\begin{align}\n",
    "    F(\\tau) + C(y_{\\tau:(\\tau^*-1)}) + K > F(\\tau^*)\n",
    "\\end{align}\n",
    "\n",
    "Then at every step $\\tau^*$, we prune all points but $\\tau$ which minimises the cost $F(\\tau^*)$. If we are allowing `min_seg_len` -- minimum segment length -- then we also have to keep `min_seg_len` positions before $\\tau^*$ as they will be evaluated as changepoint positions for larger $\\tau^*$.\n",
    "\n",
    "Depending on `min_seg_len`, sometimes we may get a positive log-likelihood for a short segment (typically of the shortest allowable length); this may lead to sightly greater $F(\\tau^*)$ than that of a previous optimal changepoint, which will then get pruned with `K=\\beta` but will be kept with a smaller `K`, e.g. `K=0`. \n",
    "\n",
    "If this optimal changepoint is pruned, then the \"spurious\" changepoint will get incorporated into the solution. This manifests as recovering many changepoints with `K=\\beta` especially for small `min_seg_len`. If the optimal changepoint is kept, then it is likely to get selected as minimising the cost at later $\\tau^*$; so even if some intermediate $\\tau^*$ locations get \"spurious\" points added to their `cps` list, the optimal changepoint will be selected at further steps, as we move away from these short segments with e.g. positive log-likelihood."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's log the number of changepoints profiled at every step $\\tau^*$. \n",
    "\n",
    "For `opt_segm`, at every step $\\tau^*$, we consider $\\tau^*$ changepoint positions.\n",
    "\n",
    "Modify `pelt_min_counts_cps` to log number of available changepoints at each step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pelt_min_count_cps(Y, penalty_param, min_seg_len, score_function, K):\n",
    "  \n",
    "    \"\"\"\n",
    "    Generate partitioning of data using PELT method\n",
    "    Args:\n",
    "        y (array of floats): data\n",
    "        p (integer): number of parameters added per changepoint (BIC penalty)\n",
    "        k (integer): minimum considered segment length \n",
    "        score_function (function): segment scoring function\n",
    "    \n",
    "    Return:\n",
    "        List containing optimal segmentation of the data\n",
    "    \"\"\"\n",
    "    # Number of datapoints\n",
    "    n = Y.shape[1] \n",
    "\n",
    "    # BIC: p*log(n)*m for\n",
    "    # p - number of parameters added per changepoint\n",
    "    # m - number of changepoints\n",
    "    penalty = penalty_param * np.log(n)\n",
    "   \n",
    "    # Array containing maximum score (best likelihood) for subpartition of each size\n",
    "    f_scores = np.zeros(n+1)\n",
    "    f_scores[:] = math.inf\n",
    "    f_scores[0] = -penalty\n",
    " \n",
    "    # List of changepoints\n",
    "    cp = {}\n",
    "    cp[0] = [np.nan]\n",
    "    \n",
    "    # Pruned changepoints\n",
    "    pruned = []\n",
    "    avail_cps = [0]\n",
    "    r_scores = np.zeros(n)\n",
    "    r_scores[:] = -math.inf\n",
    "    \n",
    "    profiled_cps = []\n",
    "    \n",
    "    # tau_star is the index until which we are scoring\n",
    "    for tau_star in range(1, n+1):\n",
    "        #r_scores[:] = 0\n",
    "        for tau in avail_cps:\n",
    "            # Slice out the data to the right\n",
    "            data_slice = Y[:, tau:tau_star]\n",
    "            \n",
    "            # Segments of length < k are not considered\n",
    "            if (data_slice.shape[1] < min_seg_len):\n",
    "                continue\n",
    "           \n",
    "            r_scores[tau] = 2 * (-score_function(data_slice))\n",
    "            candidate_score = f_scores[tau] + r_scores[tau] + penalty\n",
    "           \n",
    "            # Update f_scores if candidate score is smaller than before\n",
    "            if (candidate_score < f_scores[tau_star]):\n",
    "                f_scores[tau_star] = candidate_score\n",
    "                cp[tau_star] = [tau] + cp[tau]\n",
    "                \n",
    "        pruned = []\n",
    "        for chp in avail_cps:\n",
    "            if not np.isinf(r_scores[chp]):\n",
    "                if f_scores[chp] + r_scores[chp] + K > f_scores[tau_star]:\n",
    "                    pruned = pruned + [chp]\n",
    "        \n",
    "        avail_cps = np.setdiff1d(avail_cps, np.array(pruned))\n",
    "        avail_cps = np.append(avail_cps, tau_star)\n",
    "        profiled_cps.append(len(avail_cps))\n",
    "        \n",
    "    return cp, f_scores, profiled_cps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run with `K=0`, `K=\\beta/2`, and `K=beta`. (The first two recover the optimal solution.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Method: <function pelt_min_count_cps at 0x7f5673dde268>, time: 3.428638458251953\n",
      " Found changepoints: [150, 300, 446], Loglik: 1126.6793436724063\n"
     ]
    }
   ],
   "source": [
    "method = pelt_min_count_cps\n",
    "min_seg_len = 2\n",
    "penalty_param = 3\n",
    "start = time.time()\n",
    "cps_k0, f_scores_k0, profiled_cps_k0 = method(Y, penalty_param, min_seg_len, norm_likelihood, K=0)\n",
    "end = time.time()\n",
    "print(f\" Method: {method}, time: {end-start}\")\n",
    "#cps = cps[Y.shape[1]][::-1]\n",
    "print(f\" Found changepoints: {cps_k0[Y.shape[1]][::-1][2:]}, Loglik: {f_scores_k0[Y.shape[1]]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Method: <function pelt_min_count_cps at 0x7f5673dde268>, time: 0.1712636947631836\n",
      " Found changepoints: [150, 300, 446], Loglik: 1126.6793436724063\n"
     ]
    }
   ],
   "source": [
    "method = pelt_min_count_cps\n",
    "min_seg_len = 2\n",
    "penalty_param = 3\n",
    "start = time.time()\n",
    "cps, f_scores, profiled_cps_kbeta2 = method(Y, penalty_param, min_seg_len, norm_likelihood, K=beta/2)\n",
    "end = time.time()\n",
    "print(f\" Method: {method}, time: {end-start}\")\n",
    "cps = cps[Y.shape[1]][::-1]\n",
    "print(f\" Found changepoints: {cps[2:]}, Loglik: {f_scores[Y.shape[1]]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Method: <function pelt_min_count_cps at 0x7f5673dde268>, time: 0.1660621166229248\n",
      " Found changepoints: [33, 150, 171, 173, 246, 256, 258, 300], Loglik: 1193.9101485357069\n"
     ]
    }
   ],
   "source": [
    "method = pelt_min_count_cps\n",
    "min_seg_len = 2\n",
    "penalty_param = 3\n",
    "beta = penalty_param * np.log(Y.shape[1])\n",
    "start = time.time()\n",
    "cps, f_scores, profiled_cps_kbeta = method(Y, penalty_param, min_seg_len, norm_likelihood, K=beta)\n",
    "end = time.time()\n",
    "print(f\" Method: {method}, time: {end-start}\")\n",
    "cps = cps[Y.shape[1]][::-1]\n",
    "print(f\" Found changepoints: {cps[2:]}, Loglik: {f_scores[Y.shape[1]]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusion\n",
    "\n",
    "Pruning happens when a changepoint at $t$ is found. \n",
    "\n",
    "\\begin{align}\n",
    "    F(\\tau^*) = F(t) + C(y_{t:(\\tau^*-1)}) + \\beta\n",
    "\\end{align}\n",
    "\n",
    "Then, some $\\tau$ give worse log-likelihood when used as split and are pruned:\n",
    "\n",
    "\\begin{align}\n",
    "    F(\\tau) + C(y_{\\tau:(\\tau^*-1)}) > F(\\tau^*)\n",
    "\\end{align}\n",
    "\n",
    "Indeed, one must use $K=0$ when using costs set to likelihoods in order to satisfy the condition in the paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f567384ac18>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f567380c198>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(profiled_cps_k0) # K=0\n",
    "#plt.plot(profiled_cps_kbeta2) # K=beta/2\n",
    "#plt.plot(profiled_cps_kbeta) # K = beta\n",
    "#plt.plot(np.linspace(1, 451, 450), np.linspace(1, 451, 450)) # optimal segmentation\n",
    "\n",
    "# All t_star when a new changepoint was found\n",
    "# read off from cps_k0 below\n",
    "seq = np.array([35, 152, 173, 248, 258, 301, 302, 449])\n",
    "for n in seq:\n",
    "    plt.axvline(n, color='blue', linestyle='--')\n",
    "\n",
    "plt.show()\n",
    "\n",
    "plt.plot(Y.T)\n",
    "for n in seq:\n",
    "    plt.axvline(n, color='blue', linestyle='--')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: [nan],\n",
       " 2: [0, nan],\n",
       " 3: [0, nan],\n",
       " 4: [0, nan],\n",
       " 5: [0, nan],\n",
       " 6: [0, nan],\n",
       " 7: [0, nan],\n",
       " 8: [0, nan],\n",
       " 9: [0, nan],\n",
       " 10: [0, nan],\n",
       " 11: [0, nan],\n",
       " 12: [0, nan],\n",
       " 13: [0, nan],\n",
       " 14: [0, nan],\n",
       " 15: [0, nan],\n",
       " 16: [0, nan],\n",
       " 17: [0, nan],\n",
       " 18: [0, nan],\n",
       " 19: [0, nan],\n",
       " 20: [0, nan],\n",
       " 21: [0, nan],\n",
       " 22: [0, nan],\n",
       " 23: [0, nan],\n",
       " 24: [0, nan],\n",
       " 25: [0, nan],\n",
       " 26: [0, nan],\n",
       " 27: [0, nan],\n",
       " 28: [0, nan],\n",
       " 29: [0, nan],\n",
       " 30: [0, nan],\n",
       " 31: [0, nan],\n",
       " 32: [0, nan],\n",
       " 33: [0, nan],\n",
       " 34: [0, nan],\n",
       " 35: [33, 0, nan],\n",
       " 36: [0, nan],\n",
       " 37: [0, nan],\n",
       " 38: [0, nan],\n",
       " 39: [0, nan],\n",
       " 40: [0, nan],\n",
       " 41: [0, nan],\n",
       " 42: [0, nan],\n",
       " 43: [0, nan],\n",
       " 44: [0, nan],\n",
       " 45: [0, nan],\n",
       " 46: [0, nan],\n",
       " 47: [0, nan],\n",
       " 48: [0, nan],\n",
       " 49: [0, nan],\n",
       " 50: [0, nan],\n",
       " 51: [0, nan],\n",
       " 52: [0, nan],\n",
       " 53: [0, nan],\n",
       " 54: [0, nan],\n",
       " 55: [0, nan],\n",
       " 56: [0, nan],\n",
       " 57: [0, nan],\n",
       " 58: [0, nan],\n",
       " 59: [0, nan],\n",
       " 60: [0, nan],\n",
       " 61: [0, nan],\n",
       " 62: [0, nan],\n",
       " 63: [0, nan],\n",
       " 64: [0, nan],\n",
       " 65: [0, nan],\n",
       " 66: [0, nan],\n",
       " 67: [0, nan],\n",
       " 68: [0, nan],\n",
       " 69: [0, nan],\n",
       " 70: [0, nan],\n",
       " 71: [0, nan],\n",
       " 72: [0, nan],\n",
       " 73: [0, nan],\n",
       " 74: [0, nan],\n",
       " 75: [0, nan],\n",
       " 76: [0, nan],\n",
       " 77: [0, nan],\n",
       " 78: [0, nan],\n",
       " 79: [0, nan],\n",
       " 80: [0, nan],\n",
       " 81: [0, nan],\n",
       " 82: [0, nan],\n",
       " 83: [0, nan],\n",
       " 84: [0, nan],\n",
       " 85: [0, nan],\n",
       " 86: [0, nan],\n",
       " 87: [0, nan],\n",
       " 88: [0, nan],\n",
       " 89: [0, nan],\n",
       " 90: [0, nan],\n",
       " 91: [0, nan],\n",
       " 92: [0, nan],\n",
       " 93: [0, nan],\n",
       " 94: [0, nan],\n",
       " 95: [0, nan],\n",
       " 96: [0, nan],\n",
       " 97: [0, nan],\n",
       " 98: [0, nan],\n",
       " 99: [0, nan],\n",
       " 100: [0, nan],\n",
       " 101: [0, nan],\n",
       " 102: [0, nan],\n",
       " 103: [0, nan],\n",
       " 104: [0, nan],\n",
       " 105: [0, nan],\n",
       " 106: [0, nan],\n",
       " 107: [0, nan],\n",
       " 108: [0, nan],\n",
       " 109: [0, nan],\n",
       " 110: [0, nan],\n",
       " 111: [0, nan],\n",
       " 112: [0, nan],\n",
       " 113: [0, nan],\n",
       " 114: [0, nan],\n",
       " 115: [0, nan],\n",
       " 116: [0, nan],\n",
       " 117: [0, nan],\n",
       " 118: [0, nan],\n",
       " 119: [0, nan],\n",
       " 120: [0, nan],\n",
       " 121: [0, nan],\n",
       " 122: [0, nan],\n",
       " 123: [0, nan],\n",
       " 124: [0, nan],\n",
       " 125: [0, nan],\n",
       " 126: [0, nan],\n",
       " 127: [0, nan],\n",
       " 128: [0, nan],\n",
       " 129: [0, nan],\n",
       " 130: [0, nan],\n",
       " 131: [0, nan],\n",
       " 132: [0, nan],\n",
       " 133: [0, nan],\n",
       " 134: [0, nan],\n",
       " 135: [0, nan],\n",
       " 136: [0, nan],\n",
       " 137: [0, nan],\n",
       " 138: [0, nan],\n",
       " 139: [0, nan],\n",
       " 140: [0, nan],\n",
       " 141: [0, nan],\n",
       " 142: [0, nan],\n",
       " 143: [0, nan],\n",
       " 144: [0, nan],\n",
       " 145: [0, nan],\n",
       " 146: [0, nan],\n",
       " 147: [0, nan],\n",
       " 148: [0, nan],\n",
       " 149: [0, nan],\n",
       " 150: [0, nan],\n",
       " 151: [0, nan],\n",
       " 152: [150, 0, nan],\n",
       " 153: [150, 0, nan],\n",
       " 154: [150, 0, nan],\n",
       " 155: [150, 0, nan],\n",
       " 156: [150, 0, nan],\n",
       " 157: [150, 0, nan],\n",
       " 158: [150, 0, nan],\n",
       " 159: [150, 0, nan],\n",
       " 160: [150, 0, nan],\n",
       " 161: [150, 0, nan],\n",
       " 162: [150, 0, nan],\n",
       " 163: [150, 0, nan],\n",
       " 164: [150, 0, nan],\n",
       " 165: [150, 0, nan],\n",
       " 166: [150, 0, nan],\n",
       " 167: [150, 0, nan],\n",
       " 168: [150, 0, nan],\n",
       " 169: [150, 0, nan],\n",
       " 170: [150, 0, nan],\n",
       " 171: [150, 0, nan],\n",
       " 172: [150, 0, nan],\n",
       " 173: [171, 150, 0, nan],\n",
       " 174: [150, 0, nan],\n",
       " 175: [150, 0, nan],\n",
       " 176: [150, 0, nan],\n",
       " 177: [150, 0, nan],\n",
       " 178: [150, 0, nan],\n",
       " 179: [150, 0, nan],\n",
       " 180: [150, 0, nan],\n",
       " 181: [150, 0, nan],\n",
       " 182: [150, 0, nan],\n",
       " 183: [150, 0, nan],\n",
       " 184: [150, 0, nan],\n",
       " 185: [150, 0, nan],\n",
       " 186: [150, 0, nan],\n",
       " 187: [150, 0, nan],\n",
       " 188: [150, 0, nan],\n",
       " 189: [150, 0, nan],\n",
       " 190: [150, 0, nan],\n",
       " 191: [150, 0, nan],\n",
       " 192: [150, 0, nan],\n",
       " 193: [150, 0, nan],\n",
       " 194: [150, 0, nan],\n",
       " 195: [150, 0, nan],\n",
       " 196: [150, 0, nan],\n",
       " 197: [150, 0, nan],\n",
       " 198: [150, 0, nan],\n",
       " 199: [150, 0, nan],\n",
       " 200: [150, 0, nan],\n",
       " 201: [150, 0, nan],\n",
       " 202: [150, 0, nan],\n",
       " 203: [150, 0, nan],\n",
       " 204: [150, 0, nan],\n",
       " 205: [150, 0, nan],\n",
       " 206: [150, 0, nan],\n",
       " 207: [150, 0, nan],\n",
       " 208: [150, 0, nan],\n",
       " 209: [150, 0, nan],\n",
       " 210: [150, 0, nan],\n",
       " 211: [150, 0, nan],\n",
       " 212: [150, 0, nan],\n",
       " 213: [150, 0, nan],\n",
       " 214: [150, 0, nan],\n",
       " 215: [150, 0, nan],\n",
       " 216: [150, 0, nan],\n",
       " 217: [150, 0, nan],\n",
       " 218: [150, 0, nan],\n",
       " 219: [150, 0, nan],\n",
       " 220: [150, 0, nan],\n",
       " 221: [150, 0, nan],\n",
       " 222: [150, 0, nan],\n",
       " 223: [150, 0, nan],\n",
       " 224: [150, 0, nan],\n",
       " 225: [150, 0, nan],\n",
       " 226: [150, 0, nan],\n",
       " 227: [150, 0, nan],\n",
       " 228: [150, 0, nan],\n",
       " 229: [150, 0, nan],\n",
       " 230: [150, 0, nan],\n",
       " 231: [150, 0, nan],\n",
       " 232: [150, 0, nan],\n",
       " 233: [150, 0, nan],\n",
       " 234: [150, 0, nan],\n",
       " 235: [150, 0, nan],\n",
       " 236: [150, 0, nan],\n",
       " 237: [150, 0, nan],\n",
       " 238: [150, 0, nan],\n",
       " 239: [150, 0, nan],\n",
       " 240: [150, 0, nan],\n",
       " 241: [150, 0, nan],\n",
       " 242: [150, 0, nan],\n",
       " 243: [150, 0, nan],\n",
       " 244: [150, 0, nan],\n",
       " 245: [150, 0, nan],\n",
       " 246: [150, 0, nan],\n",
       " 247: [150, 0, nan],\n",
       " 248: [246, 150, 0, nan],\n",
       " 249: [150, 0, nan],\n",
       " 250: [150, 0, nan],\n",
       " 251: [150, 0, nan],\n",
       " 252: [150, 0, nan],\n",
       " 253: [150, 0, nan],\n",
       " 254: [150, 0, nan],\n",
       " 255: [150, 0, nan],\n",
       " 256: [150, 0, nan],\n",
       " 257: [150, 0, nan],\n",
       " 258: [256, 150, 0, nan],\n",
       " 259: [150, 0, nan],\n",
       " 260: [150, 0, nan],\n",
       " 261: [150, 0, nan],\n",
       " 262: [150, 0, nan],\n",
       " 263: [150, 0, nan],\n",
       " 264: [150, 0, nan],\n",
       " 265: [150, 0, nan],\n",
       " 266: [150, 0, nan],\n",
       " 267: [150, 0, nan],\n",
       " 268: [150, 0, nan],\n",
       " 269: [150, 0, nan],\n",
       " 270: [150, 0, nan],\n",
       " 271: [150, 0, nan],\n",
       " 272: [150, 0, nan],\n",
       " 273: [150, 0, nan],\n",
       " 274: [150, 0, nan],\n",
       " 275: [150, 0, nan],\n",
       " 276: [150, 0, nan],\n",
       " 277: [150, 0, nan],\n",
       " 278: [150, 0, nan],\n",
       " 279: [150, 0, nan],\n",
       " 280: [150, 0, nan],\n",
       " 281: [150, 0, nan],\n",
       " 282: [150, 0, nan],\n",
       " 283: [150, 0, nan],\n",
       " 284: [150, 0, nan],\n",
       " 285: [150, 0, nan],\n",
       " 286: [150, 0, nan],\n",
       " 287: [150, 0, nan],\n",
       " 288: [150, 0, nan],\n",
       " 289: [150, 0, nan],\n",
       " 290: [150, 0, nan],\n",
       " 291: [150, 0, nan],\n",
       " 292: [150, 0, nan],\n",
       " 293: [150, 0, nan],\n",
       " 294: [150, 0, nan],\n",
       " 295: [150, 0, nan],\n",
       " 296: [150, 0, nan],\n",
       " 297: [150, 0, nan],\n",
       " 298: [150, 0, nan],\n",
       " 299: [150, 0, nan],\n",
       " 300: [150, 0, nan],\n",
       " 301: [299, 150, 0, nan],\n",
       " 302: [300, 150, 0, nan],\n",
       " 303: [300, 150, 0, nan],\n",
       " 304: [300, 150, 0, nan],\n",
       " 305: [300, 150, 0, nan],\n",
       " 306: [300, 150, 0, nan],\n",
       " 307: [300, 150, 0, nan],\n",
       " 308: [300, 150, 0, nan],\n",
       " 309: [300, 150, 0, nan],\n",
       " 310: [300, 150, 0, nan],\n",
       " 311: [300, 150, 0, nan],\n",
       " 312: [300, 150, 0, nan],\n",
       " 313: [300, 150, 0, nan],\n",
       " 314: [300, 150, 0, nan],\n",
       " 315: [300, 150, 0, nan],\n",
       " 316: [300, 150, 0, nan],\n",
       " 317: [300, 150, 0, nan],\n",
       " 318: [300, 150, 0, nan],\n",
       " 319: [300, 150, 0, nan],\n",
       " 320: [300, 150, 0, nan],\n",
       " 321: [300, 150, 0, nan],\n",
       " 322: [300, 150, 0, nan],\n",
       " 323: [300, 150, 0, nan],\n",
       " 324: [300, 150, 0, nan],\n",
       " 325: [300, 150, 0, nan],\n",
       " 326: [300, 150, 0, nan],\n",
       " 327: [300, 150, 0, nan],\n",
       " 328: [300, 150, 0, nan],\n",
       " 329: [300, 150, 0, nan],\n",
       " 330: [300, 150, 0, nan],\n",
       " 331: [300, 150, 0, nan],\n",
       " 332: [300, 150, 0, nan],\n",
       " 333: [300, 150, 0, nan],\n",
       " 334: [300, 150, 0, nan],\n",
       " 335: [300, 150, 0, nan],\n",
       " 336: [300, 150, 0, nan],\n",
       " 337: [300, 150, 0, nan],\n",
       " 338: [300, 150, 0, nan],\n",
       " 339: [300, 150, 0, nan],\n",
       " 340: [300, 150, 0, nan],\n",
       " 341: [300, 150, 0, nan],\n",
       " 342: [300, 150, 0, nan],\n",
       " 343: [300, 150, 0, nan],\n",
       " 344: [300, 150, 0, nan],\n",
       " 345: [300, 150, 0, nan],\n",
       " 346: [300, 150, 0, nan],\n",
       " 347: [300, 150, 0, nan],\n",
       " 348: [300, 150, 0, nan],\n",
       " 349: [300, 150, 0, nan],\n",
       " 350: [300, 150, 0, nan],\n",
       " 351: [300, 150, 0, nan],\n",
       " 352: [300, 150, 0, nan],\n",
       " 353: [300, 150, 0, nan],\n",
       " 354: [300, 150, 0, nan],\n",
       " 355: [300, 150, 0, nan],\n",
       " 356: [300, 150, 0, nan],\n",
       " 357: [300, 150, 0, nan],\n",
       " 358: [300, 150, 0, nan],\n",
       " 359: [300, 150, 0, nan],\n",
       " 360: [300, 150, 0, nan],\n",
       " 361: [300, 150, 0, nan],\n",
       " 362: [300, 150, 0, nan],\n",
       " 363: [300, 150, 0, nan],\n",
       " 364: [300, 150, 0, nan],\n",
       " 365: [300, 150, 0, nan],\n",
       " 366: [300, 150, 0, nan],\n",
       " 367: [300, 150, 0, nan],\n",
       " 368: [300, 150, 0, nan],\n",
       " 369: [300, 150, 0, nan],\n",
       " 370: [300, 150, 0, nan],\n",
       " 371: [300, 150, 0, nan],\n",
       " 372: [300, 150, 0, nan],\n",
       " 373: [300, 150, 0, nan],\n",
       " 374: [300, 150, 0, nan],\n",
       " 375: [300, 150, 0, nan],\n",
       " 376: [300, 150, 0, nan],\n",
       " 377: [300, 150, 0, nan],\n",
       " 378: [300, 150, 0, nan],\n",
       " 379: [300, 150, 0, nan],\n",
       " 380: [300, 150, 0, nan],\n",
       " 381: [300, 150, 0, nan],\n",
       " 382: [300, 150, 0, nan],\n",
       " 383: [300, 150, 0, nan],\n",
       " 384: [300, 150, 0, nan],\n",
       " 385: [300, 150, 0, nan],\n",
       " 386: [300, 150, 0, nan],\n",
       " 387: [300, 150, 0, nan],\n",
       " 388: [300, 150, 0, nan],\n",
       " 389: [300, 150, 0, nan],\n",
       " 390: [300, 150, 0, nan],\n",
       " 391: [300, 150, 0, nan],\n",
       " 392: [300, 150, 0, nan],\n",
       " 393: [300, 150, 0, nan],\n",
       " 394: [300, 150, 0, nan],\n",
       " 395: [300, 150, 0, nan],\n",
       " 396: [300, 150, 0, nan],\n",
       " 397: [300, 150, 0, nan],\n",
       " 398: [300, 150, 0, nan],\n",
       " 399: [300, 150, 0, nan],\n",
       " 400: [300, 150, 0, nan],\n",
       " 401: [300, 150, 0, nan],\n",
       " 402: [300, 150, 0, nan],\n",
       " 403: [300, 150, 0, nan],\n",
       " 404: [300, 150, 0, nan],\n",
       " 405: [300, 150, 0, nan],\n",
       " 406: [300, 150, 0, nan],\n",
       " 407: [300, 150, 0, nan],\n",
       " 408: [300, 150, 0, nan],\n",
       " 409: [300, 150, 0, nan],\n",
       " 410: [300, 150, 0, nan],\n",
       " 411: [300, 150, 0, nan],\n",
       " 412: [300, 150, 0, nan],\n",
       " 413: [300, 150, 0, nan],\n",
       " 414: [300, 150, 0, nan],\n",
       " 415: [300, 150, 0, nan],\n",
       " 416: [300, 150, 0, nan],\n",
       " 417: [300, 150, 0, nan],\n",
       " 418: [300, 150, 0, nan],\n",
       " 419: [300, 150, 0, nan],\n",
       " 420: [300, 150, 0, nan],\n",
       " 421: [300, 150, 0, nan],\n",
       " 422: [300, 150, 0, nan],\n",
       " 423: [300, 150, 0, nan],\n",
       " 424: [300, 150, 0, nan],\n",
       " 425: [300, 150, 0, nan],\n",
       " 426: [300, 150, 0, nan],\n",
       " 427: [300, 150, 0, nan],\n",
       " 428: [300, 150, 0, nan],\n",
       " 429: [300, 150, 0, nan],\n",
       " 430: [300, 150, 0, nan],\n",
       " 431: [300, 150, 0, nan],\n",
       " 432: [300, 150, 0, nan],\n",
       " 433: [300, 150, 0, nan],\n",
       " 434: [300, 150, 0, nan],\n",
       " 435: [300, 150, 0, nan],\n",
       " 436: [300, 150, 0, nan],\n",
       " 437: [300, 150, 0, nan],\n",
       " 438: [300, 150, 0, nan],\n",
       " 439: [300, 150, 0, nan],\n",
       " 440: [300, 150, 0, nan],\n",
       " 441: [300, 150, 0, nan],\n",
       " 442: [300, 150, 0, nan],\n",
       " 443: [300, 150, 0, nan],\n",
       " 444: [300, 150, 0, nan],\n",
       " 445: [300, 150, 0, nan],\n",
       " 446: [300, 150, 0, nan],\n",
       " 447: [300, 150, 0, nan],\n",
       " 448: [300, 150, 0, nan],\n",
       " 449: [446, 300, 150, 0, nan],\n",
       " 450: [446, 300, 150, 0, nan]}"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cps_k0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f2e6378a438>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(profiled_cps_kbeta2) # K=beta/2\n",
    "plt.plot(profiled_cps_kbeta) # K=beta\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For `K=\\beta`, at steps $\\forall \\tau^* >$ `min_seg_len`, the number of considered changepoints is `min_seg_len+1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 3, 3, 3, 3, 3, 3, 3, 3]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "profiled_cps_kbeta[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For `K=\\beta/2`, at steps $\\forall \\tau^* >$ `min_seg_len`, the number of considered changepoints is sometimes larger than `min_seg_len+1` due to pruning less changepoints."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 3, 3, 3, 4, 3, 3, 3, 4]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "profiled_cps_kbeta2[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In my experiments, using PELT with `K=0` seems to agree with the `opt_segm`. This is indeed the right value to use with cost=likelihood."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To demonstrate, simulate data 10 times, run `opt_segm`, and `pelt` with `K=0` and `K=\\beta`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mu=0, sigma=1, mu1=4, sigma1=1, mu2=2, sigma2=2, counter: 0\n",
      "mu=0, sigma=1, mu1=6, sigma1=1, mu2=6, sigma2=2, counter: 1\n",
      "mu=0, sigma=1, mu1=3, sigma1=1, mu2=4, sigma2=2, counter: 2\n",
      "mu=0, sigma=1, mu1=2, sigma1=1, mu2=3, sigma2=2, counter: 3\n",
      "mu=0, sigma=1, mu1=9, sigma1=1, mu2=5, sigma2=2, counter: 4\n",
      "mu=0, sigma=1, mu1=7, sigma1=1, mu2=5, sigma2=2, counter: 5\n",
      "mu=0, sigma=1, mu1=9, sigma1=1, mu2=8, sigma2=2, counter: 6\n",
      "mu=0, sigma=1, mu1=1, sigma1=1, mu2=3, sigma2=2, counter: 7\n",
      "mu=0, sigma=1, mu1=4, sigma1=1, mu2=0, sigma2=2, counter: 8\n",
      "mu=0, sigma=1, mu1=4, sigma1=1, mu2=7, sigma2=2, counter: 9\n"
     ]
    }
   ],
   "source": [
    "G = 150\n",
    "N = 1\n",
    "min_seg_len = 5\n",
    "penalty_param = 3\n",
    "beta = penalty_param * np.log(Y.shape[1])\n",
    "\n",
    "counter = 10\n",
    "all_cps_opt_segm = []\n",
    "all_lls_opt_segm = []\n",
    "\n",
    "all_cps_pelt_k0 = []\n",
    "all_lls_pelt_k0 = []\n",
    "\n",
    "all_cps_pelt_kbeta = []\n",
    "all_lls_pelt_kbeta = []\n",
    "for c in range(counter):\n",
    "    \n",
    "    mu = np.random.randint(10)\n",
    "    mu2 = np.random.randint(10)\n",
    "    \n",
    "    Y = opt.generate_gaussian_data(G=G, N=1, mu=mu, mu2=mu2, sigma=2, plot=False)\n",
    "    \n",
    "    method = opt_segm_min\n",
    "    cps, f_scores = method(Y, penalty_param, min_seg_len, norm_likelihood)\n",
    "    all_cps_opt_segm.append(cps[Y.shape[1]][::-1][2:])\n",
    "    all_lls_opt_segm.append(f_scores[Y.shape[1]])\n",
    "    \n",
    "    method = pelt_min\n",
    "    cps, f_scores = method(Y, penalty_param, min_seg_len, norm_likelihood, K=0)\n",
    "    all_cps_pelt_k0.append(cps[Y.shape[1]][::-1][2:])\n",
    "    all_lls_pelt_k0.append(f_scores[Y.shape[1]])\n",
    "    \n",
    "    cps, f_scores = method(Y, penalty_param, min_seg_len, norm_likelihood, K=beta)\n",
    "    all_cps_pelt_kbeta.append(cps[Y.shape[1]][::-1][2:])\n",
    "    all_lls_pelt_kbeta.append(f_scores[Y.shape[1]])\n",
    "    \n",
    "    print(f\"mu=0, sigma=1, mu1={mu}, sigma1=1, mu2={mu2}, sigma2=2, counter: {c}\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`opt_segm` and `pelt` with `K=0` always agree."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True]], dtype=bool)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.equal(all_cps_opt_segm, all_cps_pelt_k0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`pelt` with `K=\\beta` sometimes recovers suboptimal solutions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_cps_opt_segm == all_cps_pelt_kbeta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f2e6359fe80>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(all_lls_pelt_k0, all_lls_pelt_kbeta, '.')\n",
    "plt.plot(np.linspace(1400,1600,10), np.linspace(1400,1600,10))\n",
    "plt.xlabel(\"LL with K=0\")\n",
    "plt.ylabel(\"LL with K=beta\")\n",
    "plt.gca().set_aspect('equal', adjustable='box')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[150, 300],\n",
       " [150, 301],\n",
       " [150, 301],\n",
       " [149, 299],\n",
       " [150, 300],\n",
       " [150, 298],\n",
       " [150, 300],\n",
       " [150, 303],\n",
       " [150, 300],\n",
       " [150, 300]]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_cps_opt_segm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[150, 300],\n",
       " [150, 301],\n",
       " [150, 301],\n",
       " [149, 299],\n",
       " [150, 300],\n",
       " [150, 298],\n",
       " [150, 300],\n",
       " [150, 303],\n",
       " [150, 300],\n",
       " [150, 300]]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_cps_pelt_k0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[150, 300],\n",
       " [150, 301],\n",
       " [150, 225, 237, 303],\n",
       " [149, 352, 358],\n",
       " [150, 300],\n",
       " [150, 298],\n",
       " [150, 359],\n",
       " [155, 304],\n",
       " [150, 300],\n",
       " [150, 307]]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_cps_pelt_kbeta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_lls_pelt_k0 < all_lls_pelt_kbeta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Closing note\n",
    "\n",
    "`Correct value to use is K=0 when using cost equal to likelihood.`\n",
    "\n",
    "Earlier observations regarding `K`: While it appears possible to tune the value of `K` to profile fewer changepoints at each step $\\tau^*$, it is not possible to do that without running the optimal segmentation method for validation, which then defeats the purpose of using PELT for speedups. \n",
    "\n",
    "One possible scenario is to do multiple runs with progressively decreasing `K` from `\\beta` to a lower value (probably not 0 as then I might just run it with `K=0` and recover optimal segmentation); and then pick the best local optimum, hoping that it will also be global. (If the log-likelihood stops decreasing, we found a global optimum.) The advantage of this is the very small number of changepoints profiled at each step.\n",
    "\n",
    "Finally, it seems that increasing `min_seg_len` can also help finding the optimal segmentation even with `K=\\beta`. Maybe one can also vary this parameter in the multiple runs scenario; however, this increases the number of profiled changepoints as it is  `min_seg_len+1`."
   ]
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}