lindeloev / mcp

Regression with Multiple Change Points

mcp: Regression with Multiple Change Points

mcp does regression with one or Multiple Change Points (MCP) between Generalized and hierarchical Linear Segments using Bayesian inference. mcp aims to provide maximum flexibility for analyses with a priori knowledge about the number of change points and the form of the segments in between.

Change points are also called switch points, break points, broken line regression, broken stick regression, bilinear regression, piecewise linear regression, local linear regression, segmented regression, and (performance) discontinuity models. mcp aims to be be useful for all of them. See how mcp compares to other R packages.

Under the hood, mcp takes a formula-representation of linear segments and turns it into JAGS code. mcp leverages the power of tidybayes, bayesplot, coda, and loo to make change point analysis easy and powerful.

Install

1. Install the latest version of JAGS. Linux users can fetch binaries here.

2. Install from CRAN:

   install.packages("mcp")

   or install the development version from GitHub:

   if (!requireNamespace("remotes")) install.packages("remotes")
   remotes::install_github("lindeloev/mcp")

At a glance

Here are some example mcp models. mcp takes a list of formulas - one for each segment. The change point(s) are the x at which data changes from being better predicted by one formula to the next. The first formula is just response ~ predictors and the most common formula for segment 2+ would be ~ predictors (more details here).

Scroll down to see brief introductions to each of these, or browse the website articles for more thorough worked examples and discussions.

Brief worked example

Fit a model

The following model infers the two change points between three segments.

library(mcp)

# Define the model
model = list(
  response ~ 1,  # plateau (int_1)
  ~ 0 + time,    # joined slope (time_2) at cp_1
  ~ 1 + time     # disjoined slope (int_3, time_3) at cp_2
)

# Get example data and fit it
ex = mcp_example("demo")
fit = mcp(model, data = ex$data)

Plot and summary

The default plot includes data, fitted lines drawn randomly from the posterior, and change point(s) posterior density for each chain:

plot(fit)

Use summary() to summarise the posterior distribution as well as sampling diagnostics. They were simulated using mcp (see mcp_example("demo")$call) so the summary include the "true" values in the column sim and the column match show whether this true value is within the interval:

summary(fit)

Family: gaussian(link = 'identity')
Iterations: 9000 from 3 chains.
Segments:
  1: response ~ 1
  2: response ~ 1 ~ 0 + time
  3: response ~ 1 ~ 1 + time

Population-level parameters:
    name match  sim  mean lower  upper Rhat n.eff
    cp_1    OK 30.0 30.27 23.19 38.760    1   384
    cp_2    OK 70.0 69.78 69.27 70.238    1  5792
   int_1    OK 10.0 10.26  8.82 11.768    1  1480
   int_3    OK  0.0  0.44 -2.49  3.428    1   810
 sigma_1    OK  4.0  4.01  3.43  4.591    1  3852
  time_2    OK  0.5  0.53  0.40  0.662    1   437
  time_3    OK -0.2 -0.22 -0.38 -0.035    1   834

rhat is the Gelman-Rubin convergence diagnostic, eff is the effective sample size. You may also want to do a posterior predictive check using pp_check(fit).

plot_pars(fit) can be used to inspect the posteriors and convergence of all parameters. See the documentation of plot_pars() for many other plotting options. Here, we plot just the (population-level) change points. They often have "strange" posterior distributions, highlighting the need for a computational approach:

plot_pars(fit, regex_pars = "cp_")

Use fitted(fit) and predict(fit) to get fits and predictions for in-sample and out-of-sample data.

Tests and model comparison

We can test (joint) probabilities in the model using hypothesis() (see more here). For example, what is the evidence (given priors) that the first change point is later than 25 against it being less than 25?

hypothesis(fit, "cp_1 > 25")

     hypothesis mean lower upper     p   BF
1 cp_1 - 25 > 0 5.27 -1.81 13.76 0.917 11.1

For model comparisons, we can fit a null model and compare the predictive performance of the two models using (approximate) leave-one-out cross-validation (see more here). Our null model omits the first plateau and change point, essentially testing the credence of that change point:

# Define the model
model_null = list(
  response ~ 1 + time,  # intercept (int_1) and slope (time_1)
  ~ 1 + time            # disjoined slope (int_2, time_1)
)

# Fit it
fit_null = mcp(model_null, ex$data)

Leveraging the power of loo::loo, we see that the two-change-points model is preferred (it is on top), but the elpd_diff / se_diff ratio ratio indicate that this preference is not very strong.

fit$loo = loo(fit)
fit_null$loo = loo(fit_null)

loo::loo_compare(fit$loo, fit_null$loo)

       elpd_diff se_diff
model1  0.0       0.0
model2 -7.6       4.6

Highlights from in-depth guides

The articles on the mcp website go in-depth with the functionality of mcp. Here is an executive summary, to give you a quick sense of what mcp can do.

About mcp models and simulating data:

• Parameter names are int_i (intercepts), cp_i (change points), x_i (slopes), phi_i (autocorrelation), and sigma_* (variance).
• The change point model is basically an ifelse model.
• Use rel() to specify that parameters are relative to those corresponding in the previous segments.
• Generate data for all supported models using fit$simulate(). See examples in, e.g., mcp_examples("demo")$call.

Using priors:

• See priors in fit$prior.
• Set priors using mcp(..., prior = list(cp_1 = "dnorm(0, 1)", cp_1 = "dunif(0, 45)").
• The default prior for change points is fast for estimation but is mathematically "messy". The Dirichlet prior (cp_i = "dirichlet(1)") is slow but beautiful.
• Fix parameters to specific values using cp_1 = 45.
• Share parameters between segments using slope_1 = "slope_2".
• Truncate priors using T(lower, upper), e.g., int_1 = "dnorm(0, 1) T(0, )". mcp applies this automatically to change point priors to enforce order restriction. This is true for varying change points too.
• Do prior predictive checks using mcp(model, data, sample = "prior").

Varying change points:

• Get posteriors using ranef(fit).
• Plot using plot(fit, facet_by = "my_group") and plot_pars(fit, pars = "varying", type = "dens_overlay", ncol = 3).
• The default priors restrict varying change points to lie between the two adjacent change points.

Supported families and link functions:

• mcp currently supports specific combinations of families (gaussian(), binomial(), bernoulli(), and poisson()) and link functions (identity, logit, probit, and log).
• Use informative priors to avoid issues when using non-default priors.
• Use binomial(link = "logit") for binomial change points in mcp. Also relevant for bernoulli(link = "logit").
• Use poisson(link = "log") for Poisson change points in mcp.
• Get results on the parameter scale rather than the observed scale using plot(fit, scale = "linear") or predict(fit, scale = "linear").

Model comparison and hypothesis testing:

• Do Leave-One-Out Cross-Validation using loo(fit) and loo::loo_compare(fit1$loo, fit2$loo).
• Compute Savage-Dickey density rations using hypothesis(fit, "cp_1 = 40").
• Leverage directional and conditional tests to assess interval hypotheses (hypothesis(fit, "cp_1 > 30 & cp_1 < 50")), combined other hypotheses (hypothesis(fit, "cp_1 > 30 & int_1 > int_2")), etc.

Modeling variance and autoregression:

• ~ sigma(1) models an intercept change in variance. ~ sigma(0 + x) models increasing/decreasing variance.
• ~ ar(N) models Nth order autoregression on residuals. ~ar(N, 0 + x) models increasing/decreasing autocorrelation.
• You can model anything for sigma() and ar(). For example, ~ x + sigma(1 + x + I(x^2)) models polynomial change in variance with x on top of a slope on the mean.

Get fitted and predicted values and intervals:

• fitted(fit) and predict(fit) take many arguments to predict in-sample and out-of-sample values and intervals.
• Forecasting with prior knowledge about future change points.

Tips, tricks, and debugging

• Speed up fitting using mcp(..., cores = 3) / options(mcp_cores = 3), and/or fewer iterations, mcp(..., adapt = 500).
• Help convergence along using mcp(..., inits = list(cp_1 = 20, int_2 = -3)).
• Most errors will be caused by circularly defined priors.

Some examples

mcp aims to support a wide variety of models. Here are some example models for inspiration.

Means

Find the single change point between two plateaus (simulated using mcp_example("intercepts")$call).

model = list(
    y ~ 1,  # plateau (int_1)
    ~ 1     # plateau (int_2)
)
ex = mcp_example("intercepts")
fit = mcp(model, ex$data, par_x = "x")
plot(fit)

Varying change points

Here, we find the single change point between two joined slopes. While the slopes are shared by all participants, the change point varies by id. Read more about varying change points in mcp.

model = list(
  y ~ 1 + x,          # intercept + slope
  1 + (1|id) ~ 0 + x  # joined slope, varying by id
)
ex = mcp_example("varying")
fit = mcp(model, ex$data)
plot(fit, facet_by = "id")

Summarise the varying change points using ranef() or plot them using plot_pars(fit, "varying"). Again, this data was simulated using mcp (see mcp_example("varying")$call) so the columns match and sim are added to show simulation values and whether they are inside the interval. Set the width wider for a more lenient criterion.

ranef(fit, width = 0.98)

           name match   sim  mean   lower   upper Rhat n.eff
 cp_1_id[Benny]    OK -17.5 -18.1 -21.970 -14.877    1   895
  cp_1_id[Bill]    OK -10.5  -7.6 -10.658  -4.451    1   420
  cp_1_id[Cath]    OK  -3.5  -2.8  -5.634   0.027    1   888
  cp_1_id[Erin]    OK   3.5   3.1   0.041   5.952    1  3622
  cp_1_id[John]    OK  10.5  11.3   7.577  14.989    1  2321
  cp_1_id[Rose]    OK  17.5  14.1  10.485  18.079    1  5150

Generalized linear models

mcp supports Generalized Linear Modeling. See extended examples using binomial() and poisson().

Here is a binomial change point model with three segments (see simulation code: mcp_example("binomial")$call). We plot the 95% HDI too:

model = list(
  y | trials(N) ~ 1,  # constant rate
  ~ 0 + x,            # joined changing rate
  ~ 1 + x             # disjoined changing rate
)
ex = mcp_example("binomial")
fit = mcp(model, ex$data, family = binomial())
plot(fit, q_fit = TRUE)

Use plot(fit, rate = FALSE) if you want the points and fit lines on the original scale of y rather than divided by N.

Time series

mcp allows for flexible time series analysis with autoregressive residuals of arbitrary order. Below, we model a change from a plateau with strong positive AR(2) residuals to a slope with medium AR(1) residuals. These data were simulated with mcp (see simulation code: mcp_example("ar")$call) and the generating values are in the sim column. You can also do regression on the AR coefficients themselves using e.g., ar(1, 1 + x). Read more here.

model = list(
  price ~ 1 + ar(2),
  ~ 0 + time + ar(1)
)
ex = mcp_example("ar")
fit = mcp(model, ex$data)
summary(fit)

The AR(N) parameters on intercepts are named ar[order]_[segment]. All parameters, including the change point, are well recovered:

Population-level parameters:
    name match   sim    mean     lower   upper Rhat n.eff
   ar1_1    OK   0.7   0.741  5.86e-01   0.892 1.01   713
   ar1_2    OK  -0.4  -0.478 -6.88e-01  -0.255 1.00  2151
   ar2_1    OK   0.2   0.145 -6.56e-04   0.284 1.01   798
    cp_1       120.0 117.313  1.14e+02 118.963 1.05   241
   int_1        20.0  17.558  1.51e+01  19.831 1.02   293
 sigma_1    OK   5.0   4.829  4.39e+00   5.334 1.00  3750
  time_2    OK   0.5   0.517  4.85e-01   0.553 1.00   661

The fit plot shows the inferred autocorrelated nature:

plot(fit_ar)

Variance change and prediction intervals

You can model variance by adding a sigma() term to the formula. The inside sigma() can take everything that the formulas outside do. Read more in the article on variance. The example below models two change points. The first is variance-only: variance abruptly increases and then declines linearly with x. The second change point is the stop of the variance-decline and the onset of a slope on the mean.

Effects on variance is best visualized using prediction intervals. See more in the documentation for plot.mcpfit().

model = list(
  y ~ 1,
  ~ 0 + sigma(1 + x),
  ~ 0 + x
)
ex = mcp_example("variance")
fit = mcp(model, ex$data, cores = 3, adapt = 5000, iter = 5000)
plot(fit, q_predict = TRUE)

Quadratic and other exponentiations

Write exponents as I(x^N). E.g., quadratic I(x^2), cubic I(x^3), or some other power function I(x^1.5). The example below detects the onset of linear + quadratic growth. This is often called the BLQ model (Broken Line Quadratic) in nutrition research.

model = list(
  y ~ 1,
  ~ 0 + x + I(x^2)
)
ex = mcp_example("quadratic")
fit = mcp(model, ex$data)
plot(fit)

Trigonometric and others

You can use sin(x), cos(x), and tan(x) to do trigonometry. This can be useful for seasonal trends and other periodic data. You can also do exp(x), abs(x), log(x), and sqrt(x), but beware that the two latter will currently fail in segment 2+. Raise an issue if you need this.

model = list(
  y ~ 1 + sin(x),
  ~ 1 + cos(x) + x
)
ex = mcp_example("trigonometric")
fit = mcp(model, ex$data)
plot(fit)

Using rel() and priors

Read more about formula options and priors.

Here we find the two change points between three segments. The slope and intercept of segment 2 are parameterized relative to segment 1, i.e., modeling the change in intercept and slope since segment 1. So too with the second change point (cp_2) which is now the distance from cp_1.

Some of the default priors are overwritten. The first intercept (int_1) is forced to be 10, the slopes are in segment 1 and 3 is shared. It is easy to see these effects in the (simulated) data because they violate it somewhat. The first change point has to be at x = 20 or later.

model = list(
  y ~ 1 + x,
  ~ rel(1) + rel(x),
  rel(1) ~ 0 + x
)

prior = list(
  int_1 = 10,  # Constant, not estimated
  x_3 = "x_1",  # shared slope in segment 1 and 3
  int_2 = "dnorm(0, 20)",
  cp_1 = "dunif(20, 50)"  # has to occur in this interval
)
ex = mcp_example("rel_prior")
fit = mcp(model, ex$data, prior, iter = 10000)
plot(fit)

Comparing the summary to the fitted lines in the plot, we can see that int_2 and x_2 are relative values. We also see that the "wrong" priors made it harder to recover the parameters used to simulate this code (see mcp_example("rel_prior")$simulated which is represented in the match and sim columns):

summary(fit)

Population-level parameters:
    name match   sim  mean  lower upper Rhat n.eff
    cp_1    OK  25.0 23.15  20.00 25.81 1.00   297
    cp_2        40.0 51.85  47.06 56.36 1.02   428
   int_1        25.0 10.00  10.00 10.00  NaN     0
   int_2    OK -10.0 -6.86 -21.57 11.89 1.03   190
 sigma_1         7.0  9.70   8.32 11.18 1.00  7516
     x_1         1.0  1.58   1.24  1.91 1.07   120
     x_2    OK  -3.0 -3.28  -3.61 -2.96 1.04   293
     x_3         0.5  1.58   1.24  1.91 1.07   120

Do much more with the MCMC samples

Don't be constrained by these simple mcp functions. fit$samples is a regular mcmc.list object and all methods apply. You can work with the MCMC samples just as you would with brms, rstanarm, jags, or other samplers using the always excellent tidybayes:

library(tidybayes)

# Extract all parameters:
tidy_draws(fit$samples) %>%
  # tidybayes stuff here

# Extract some parameters:
fit$pars$model  # check out which parameters are inferred.
spread_draws(fit$samples, cp_1, cp_2, int_1, year_1) %>%
 # tidybayes stuff here

It may be convenient to use fitted(fit, summary = FALSE) or predict(fit, summary = FALSE) which return draws in tidybayes format, extended with additional columns for fits and predictions. For example:

head(fitted(fit, summary = FALSE))

Citation

This preprint formally introduces mcp. Find citation info at the link, call citation("mcp") or copy-paste this into your reference manager:

  @Article{,
    title = {mcp: An R Package for Regression With Multiple Change Points},
    author = {Jonas Kristoffer Lindeløv},
    journal = {OSF Preprints},
    year = {2020},
    doi = {10.31219/osf.io/fzqxv},
    encoding = {UTF-8},
  }

mcp's Issues

Missing output columns in fit()

Reprex below.

Using ex_demo, there are match and sim columns in mcpfit object, but not when using my_demo.

Is this driven by Rhat or n.eff values?

library(mcp)
#> Warning: package 'mcp' was built under R version 3.5.3

# Define the model
model <- list(
  response ~ 1, # plateau (int_1)
  ~ 0 + time, # joined slope (time_2) at cp_1
  ~ 1 + time # disjoined slope (int_3, time_3) at cp_2
)

# Fit it. The `ex_demo` dataset is included in mcp
fit <- mcp(model, data = ex_demo)
#> Compiling model graph
#>    Resolving undeclared variables
#>    Allocating nodes
#> Graph information:
#>    Observed stochastic nodes: 100
#>    Unobserved stochastic nodes: 7
#>    Total graph size: 1731
#> 
#> Initializing model
#> Finished sampling in 7.5 seconds
fit
#> Family: gaussian(link = 'identity')
#> Iterations: 9000 from 3 chains.
#> Segments:
#>   1: response ~ 1
#>   2: response ~ 1 ~ 0 + time
#>   3: response ~ 1 ~ 1 + time
#> 
#> Population-level parameters:
#>     name match  sim  mean lower upper Rhat n.eff
#>     cp_1    OK 30.0 30.57 22.57 37.96    1   355
#>     cp_2    OK 70.0 69.78 69.28 70.24    1  5621
#>    int_1    OK 10.0 10.27  8.77 11.59    1  1152
#>    int_3    OK  0.0  0.46 -2.51  3.41    1   776
#>  sigma_1    OK  4.0  4.01  3.46  4.62    1  4109
#>   time_2    OK  0.5  0.54  0.41  0.67    1   379
#>   time_3    OK -0.2 -0.22 -0.38 -0.04    1   741

my_demo <- structure(list(
  response = c(
    138.989, 97.232, 45.717, 25.919,
    12.67, 39.103, 57.598, 39.518, 43.226, 2.374, 7.972, 6.779
  ),
  time = 1:12
), class = c("tbl_df", "tbl", "data.frame"), row.names = c(
  NA,
  -12L
))

fit <- mcp(model, data = my_demo)
#> Compiling model graph
#>    Resolving undeclared variables
#>    Allocating nodes
#> Graph information:
#>    Observed stochastic nodes: 12
#>    Unobserved stochastic nodes: 7
#>    Total graph size: 235
#> 
#> Initializing model
#> Finished sampling in 0.9 seconds
fit
#> Family: gaussian(link = 'identity')
#> Iterations: 9000 from 3 chains.
#> Segments:
#>   1: response ~ 1
#>   2: response ~ 1 ~ 0 + time
#>   3: response ~ 1 ~ 1 + time
#> 
#> Population-level parameters:
#>     name  mean lower upper Rhat n.eff
#>     cp_1   2.2   1.0   5.1  1.3   110
#>     cp_2   3.3   1.2   9.1  1.3    67
#>    int_1 108.9  46.2 151.7  1.1   212
#>    int_3  36.4  -1.4  69.0  1.1   306
#>  sigma_1  24.7  12.7  41.8  1.1   236
#>   time_2  -1.1 -12.9  11.3  1.0  1191
#>   time_3  -2.0  -6.8   3.4  1.0   818

mcp() doesn't start compile

I tried basic rjags examples and they work fine (model compiled in seconds), to ensure JAGS is running properly.

Then, I experimented with mcp, but running mcp() doesn't seem to kick off JAGS at all - keeps loading, without any message; this was tried on both R 3.5.1 and 3.6.0.

I proceed with killing the run and the following message shows:

> library(mcp)
> 
> my_data <- data.frame(x = 1:50,
+                       y = c(rep(30, 25) * abs(rnorm(25)),
+                             rep(30, 25) * -abs(rnorm(25))))
> 
> # Define segments
> segments = list(
+   y ~ 1 + x,  # Intercept
+   1 ~ 1  # Intercept
+ )
> # Start sampling
> fit = mcp(segments, my_data)

Warning message:
In system(cmd, wait = FALSE, input = "") :
  'CreateProcess' failed to run 'C:\Users\Public\Data\R\R-35~1.1\bin\x64\Rscript.exe --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "parallel:::.slaveRSOCK()" MASTER=localhost PORT=11743 OUT="/dev/null" SETUPTIMEOUT=120 TIMEOUT=2592000 XDR=TRUE'
>

Seesion info

> sessionInfo()
R version 3.5.1 (2018-07-02)
Platform: x86_64-w64-mingw32/x64 (64-bit)
Running under: Windows 10 x64 (build 17134)

Matrix products: default

locale:
[1] LC_COLLATE=English_United States.1252  LC_CTYPE=English_United States.1252   
[3] LC_MONETARY=English_United States.1252 LC_NUMERIC=C                          
[5] LC_TIME=English_United States.1252    

attached base packages:
[1] stats     graphics  grDevices utils     datasets  methods   base     

other attached packages:
[1] mcp_0.1     rjags_4-9   coda_0.19-2

loaded via a namespace (and not attached):
 [1] Rcpp_1.0.2.2           rstudioapi_0.10.0-9002 magrittr_1.5           tidyselect_0.2.5      
 [5] munsell_0.5.0          colorspace_1.4-1       lattice_0.20-38        R6_2.4.0              
 [9] rlang_0.4.0            stringr_1.4.0          dplyr_0.8.3            tools_3.5.1           
[13] parallel_3.5.1         grid_3.5.1             packrat_0.5.0          gtable_0.3.0          
[17] loo_2.1.0              ellipsis_0.3.0         matrixStats_0.54.0     lazyeval_0.2.2        
[21] assertthat_0.2.1       lifecycle_0.1.0        tibble_2.1.3           crayon_1.3.4          
[25] tidyr_1.0.0            purrr_0.3.2            ggplot2_3.2.1          vctrs_0.2.0.9001      
[29] zeallot_0.1.0          glue_1.3.1             stringi_1.4.3          compiler_3.5.1        
[33] pillar_1.4.2           backports_1.1.5        scales_1.0.0           pkgconfig_2.0.3 

Function to return posterior draws/lines displayed by `plot.mcpfit`

Hello Jonas Kristoffer Lindeløv,
Great work on a package which serves a very good purpose which I am sure will see plenty of uptake. This is a question. I would like to extract the data behind the posterior draws/lines in the plot.mcpfit function. Is there user exposed function which can create these data by passing the mcpfit object and a few arguments? Many thanks,
Stuart.

Support relative parameterization and use absolute by default

Specify parameters as relative or absolute. E.g. relative parameters represent changes from the former segment while absolute is more like "classical" Piecewise Linear Regression. This will be useful in some cases where changes are more meaningful. I think that absolute parameters should be the default. Changing to relative parameterization could be done like this:

segments = list(
    y ~ 1 + x, 
    rel(1) ~ rel(1) + rel(x))

All parameters in the first segment must be absolute. Fail if rel is used there. But a change in relative intercept following a slope-only segment is meaningful enough and should work.

• rel on RHS
• rel on LHS
• Fail on rel in segment 1

Turn off autocorrelation

Turning off would just be changing to 0th order:

segments = list(
    y ~ 1 + x,
    ~ 0 + ar(1),  # start AR(1)
    ~ 0 + ar(0)  # Stop all AR
)

Implementation-wise, the "0" would just set zeros for the involved parameters, e.g., ar_[i_] = 0, i.e., leaving it purely to sigma to model the residuals.

Add posterior change point densities to the default plot

Would be great to:

• Plot dens_overlay on the x-axis
• Color it by change point (cp_1 is red, cp_2 is blue, etc.)
• Show one line per chain as dens_overlay to inspect convergence.

This would bring the non-normal nature of the change point posteriors to the fore. It would also constitute an in-your-face inspection of convergence issues.

I would like it to be default, but you should be able to turn it off, plot(fit, show_dens = FALSE). I need to think of a good argument name here.

Bug when fitting relative slope in a formula form?

I have a question regarding how to configure relative slope in a formula form.

I read the documentation and it seems we can use "rel" to fit the relative change. So I did the same for my time series use case as following.

But it gives me an upward slope which is supposed to show a downward trend based on our domain knowledge. So I inspect the "jags_code". It seems it's modeled as "(x_i-1 + x_i)" for the relative part. What I would like to fit is to model the relative change of the previous slope as a multiplier.

Thanks to the "custom_jags" argument. I twisted a little bit of the "jags_code" by specifying a multiplier parameter "f_2" that follows a uniform distribution ([0.1 ~1]) and constructing the last slope as "x_2 = f_2*x_1" to replace the previous "(x_2+x_1)" component. That gives me a much better fit in the sense of being consistent with our prior knowledge.

I'm wondering whether this is a bug of fitting with a relative slope as I'm not sure why the additive formulation(x_i-1 + x_i)) can help extrapolate the relative change. Or do you have any other suggestions to specify in a formula form for my goal? (so I don't need to twist the jags code)

Thanks very much!

plot() error given arbitrary y and x names in data

Reprex below.

The tweak for plot() method suggested in #30 is not quite perfect, as it generates the following error:

library(mcp)
  
# Define the segments that are separated by change points
segments = list(
  score ~ 1 + year,  # intercept + slope
  1 ~ 0 + year,  # joined slope
  rel(1) ~ 0,  # joined plateau starting at relative change point
  1 ~ rel(1)  # disjoined plateau with relative intercept parameterization
)

# Get an mcpfit object without samples
empty = mcp(segments, sample=FALSE)

# Now use empty$func_y() to generate data from this model.
# Set some parameter values to your liking:
data = data.frame(
  year = 1:100,  # Evaluate func_y for each of these
  score = empty$func_y(
    year = 1:100,  # x
    sigma = 12,  # standard deviation
    cp_1 = 20, cp_2 = 35, cp_3 = 80,  # change points 
    int_1 = 20, int_4 = 20,  # intercepts
    year_1 = 3, year_2 = -2  # slopes
  )
)

prior = list(
  year_1 = "dnorm(0, 5)",  # Slope of segment 1
  int_1 = "dt(10, 30, 1) T(0, )",  # t-distributed prior. Truncated to be positive.
  cp_2 = "dunif(0, 60)",  # Change point is after the first, but within 60 years.
  year_2 = -2  # Fixed slope of segment 2.
)

fit = mcp(segments, data, prior)

# adapted from plot.mcpfit
my_custom_plot(fit, "overlay")

Error: (list) object cannot be coerced to type 'double'

One more tweak to make it work; please refer to code marked with # <<< below:

[...]
    # First, let's get all the predictors in shape for func_y
    Q = Q %>%
      tidyr::expand_grid(!!x$pars$x := eval_at) %>%  # correct name of x-var
      
      # Add fitted draws (vectorized)
      dplyr::mutate(!!x$pars$y := purrr::invoke(func_y, ., type = "fitted")) %>%
      
      # Add line ID to separate lines. Mark a new line when "eval_at" repeats.
      dplyr::mutate(
        line = !!sym(x$pars$x) == min(eval_at),  # <<<
        line = cumsum(line)
      )
[...]

Move example data/fits to a function

The datasets in ex_demo, ex_ar, etc. clutter up the namespace and the documentation. Move it to a function just like https://github.com/stan-dev/posterior/blob/master/R/example_draws.R.

So mcp_example("demo") returns a list with the fields

• $model: the model used to generate the data.
• $data: the data. "simulated")`
• $fit: an mcpfit. Defaults to NULL.

A typical example in the README would then look like this:

model = list(
    ....,
    ....
)
fit = mcp(model, mcp_example("demo")$data)

or

ex =  mcp_example("demo")
ex$model  # Show it
fit = mcp(ex$model, ex$data)

Undecided:

• Consider whether to add a field for the simulation values explicitly ($simulated) or just have the user extract them via attr($data$response, "simulated").
• Having a briefer name would be nice (e.g., ex("demo")) but less semantically clear.

TO DO:

• Update README
• Update function doc examples
• Update vignettes
• Move descriptions to mcp_example() doc
• Delete old data

Unit test updates

Test that it does not break, and that the data structures are inteact:

• Test priors, including fixing and truncation.
• Use set.seed and add an extra test for more exact values, now that randomness from data generation has been avoided.
• Test allowed data types
• Test underscores in variable names
• Test y and varying effects
• Begin sampling and make 1 draw on a very small dataset - just for speed. This will test the model compilation and initialization.
• Test loo and waic
• Plots.
• Add more testing environments (R < 3.6 and Linux), cf. #27

Include demo datasets

Give users something to toy with to get acquainted with mcp.

• simulated data
• real-world data, ideally from academic papers on change point estimation or where it could/should be used.

Should it loaded with mcp or should one run data("mcp_sim1")?

Once done, update the README and mcp examples to use these datasets.

Readme

Hey! Great package! Initially I had trouble to install because some of my packages were outdated. But after updating everything it ran pretty smooth.

• It took me a bit to understand the logic of the list. I think a simple comment in the quick-start would fix this (e.g. "between each entry (a "segment") of the list, a changepoint is modelled"). After understanding this, the toolbox was intuitive to use

• readme: sampling the prior:
  empty = mcp(segments, sample=FALSE)
  Here it is implicitly assumed that segments defines "x" somehow.

• I think I'm a bit confused what the underlying model is. I get discrete changepoints but at points where there are no samples. This is still confusing me tbh.

• the rel(1) command lets you parameterize the parameter relative to the last segment. Is it also possible to parameterize to any other ones? I am thinking of a situation where two changepoints define a plateau that is different and then going back to the initial value. i.e.
  
  In this example, I might want to assume that the first and last segment / plateau have identical parameters (or at least put a prior that the difference is quite small)

Pretty good job! worked fine for me so far. I only ran it on simulated data, I have to check for real data :-) My problem with real data is that I usually have strong autocorrelation, i.e. changes are not really discrete hinges, but smoothed over time. I guess one could fit plateaus & slopes, but still no smoothness in the fit.

Support more link functions

• "identity" for binomial() and bernoulli()
• "log" for gaussian()
• "identity" for poisson()?

The hard part is coming up with priors where these don't fail too often.

Coloring the posterior estimates by CP would make interpretation of plots easier

First, fantastic package! Thank you.

When plotting the results of the model fit it can often be challenging to determine which posterior cp estimates (blue lines at bottom) correspond to the visual change points shown in the upper model curves. This is particularly difficult when one or more of the posterior estimates are bimodal, and worse still if overlapping :-(

If the individual CP posterior estimates were color coded things would be easier. You will note in my graph an attempt to identify the CP range using shaded regions and lines for the mean value.

Thanks,
Jim

Define the model with 3 CP

model = list(
y ~ 1, # plateau (int_1)
~ 0 + x, # joined slope (time_2) at cp_1
~ 1 + x, # disjoined slope (int_3, time_3) at cp_2
~ 1 + x # disjoined slope (int_4, time_4) at cp_3
)

model.string <- paste(sapply(model, function(x) Reduce(paste, deparse(x))), collapse = ", ")

Add prior knowledge to improve model

prior = list(
int_1 = 0, # Constant, not estimated
cp_1 = "dunif( 0, 200)", # has to occur in this interval
cp_3 = "dunif(300, 400)" # has to occur in this interval
)

Hypothesis tests

mcp already supports loo. Maybe we should also support more classical hypothesis tests.

• Do something akin to brms::hypothesis. Should be straight forward using tidybayes::tidy_draws() and eval(parse(text = hypothesis))?
  • Requires sampling of the prior for Savage-Dickey. Replicate the prior-writer and suffix it with something like _nolik, e.g., cp_1_nolik and cp_2_id_nolik[5]?
• Write an article/vignette (#46) with how-to and warnings about interpretability.

Support binomial, Bernoulli, etc., and associated default priors

• family = binomial()
• show all priors in fit$prior and in jags_code.
• family = bernoulli()
• family = poisson()

This should work:

segments = list(
    y | trials(N) ~ 1 + x,
    1 ~ 0)

mcp(data, segments, prior, family=binomial())

This means that all parameters are on rates/probabilities rather than observed values. family = binomial() will need to take an additional column to specify the number of trials. I have a hard-coded model working with binomial so it is very doable.

Prettier printing of lists and characters

Do this by adding print.mcplist and print.mcpstr methods and corresponding classes to the following:

Lists:

• fit$pars
• fit$prior
• fit$model
• attr(fit$data$y, "simulated")

Code:

• fit$jags_code. Used should not need to do cat(fit$jags_code)

Support consecutive relative changepoints

As described in #5

More articles

• Model comparison (once bridgesampling is implemented)
• Bernoulli (merge with binomial?)
• Model diagnostics.
• Comparison to other packages: changepoint, ecp, bcp, segmented, strucchange, tsmcp, robts:changerob.
  Some of these are superior when it comes to speed (at the cost of accurate posteriors) and unsupervised change point detection.

Custom families

Family-specific functions are currently scattered over several locations in the code and dealt with in an if-else like fashion. This hard-coding of response families makes it harder to implement new ones and maintain existing ones.

I propose storing all of this in an mcpfamily() object which extends gaussian(), etc.

• Move priors to mcpfamily()
• Move the JAGS likelihood code to mcpfamily()
• Move R random generator code to mcpfamily() (used in fit$simulate()).
• Assign a list of distributional parameters (dpar) for each family, e.g., c("mu", "sigma") for gaussian() and build regression models for each of these. Use intercept-models for all that are not explicitly included in the formulas.
• Also somehow code whether it supports ar(), weight(), etc.
• Document it in a vignette.

This is relevant for #89. Once implemented, support for stan will also be easier (#100).

tidybayes integration

Saw the announcement of the new release on Twitter, looks awesome!

I had two questions about tidybayes integration:

1. I see you're using tidy_samples instead of implementing a generic for tidybayes::tidy_draws... Are there limitations of the tidy_draws interface that motivate this choice or is there a difference in semantics? If there are changes in tidybayes that would make it possible to make the interfaces consistent I'd be open to it.

2. Any interest in implementing add_fitted_draws/add_predicted_draws/etc? I haven't come up with a good way to make that easy on package developers yet but if there was interest on your part this might be the opportunity to think through how to make that happen. There is also a feature discussion for {posterior} related to generics for these kinds of functions (stan-dev/posterior#39) that I will probably be basing future implementations of add_fitted_draws/add_predicted_draws/etc on, having your input there might be helpful too.

Support "non-linear" terms

This should work:

segments = list(
    y ~ 1 + x + I(x^2.4),
    1 ~ 0 + log(x)
)

The best solution would be to allow anything that can run in JAGS. See user manual page 42.

Multiple predictors

Each segment should take an arbitrary number of linear predictors. As with the segmented package, the only requirement is that one continuous predictor (say, x) is the dimension of the change point. The change point is simply the value on x where the predictions of y changes to a different regression model (parameter structure and/or values).

So this API should work. It has the following features:

• Support categorical predictors via dummy coding.
• Support interactions
• Each segment can have different numbers of predictors.

model = list(
    y ~ 1 + x*group + z + sigma(1 + group),  # interactions and main effects and a covariate.
    ~ 0 + x + ar(2, z),  # only one slope
    ~ 1 + group  # a range of x where group is the only predictor
)

JAGS-wise the indicator functions would be the same but now we additionally pass design matrices (X1_, X2_, etc.) and use inprod() per segment. The model above would be something like:

    # Priors for individual parameters
    cp_1 ~ ... T(MINX, MAXX)
    cp_2 ~ ... T(cp_1, MAXX)
    int_1 ~ dnorm(0, 1^-2)
    int_3 ~ ...
    xGroupFemale_1 ~ dnorm(0, 1)  # check R naming convention
    z_1 ~ dunif(0, 100)
    x_2 ~ dnorm(4, 3^-2)
    xGroupFemale_3 ~ ...

    # Model and likelihood
    for(i_ in 1:length(x1_)) {
        y_[i_] = (x_[i_] > cp_0) * (int_1 + inprod(c(xGroupFemale_1, z_1), x1_[i_, ])) + 
                (x_[i_] > cp_1) * (0 + inprod(c(x_2), x2_[i_, ])) +
                (x_[i_] > cp_2) * (int_3 + inprod(c(xGroupFemale_3), x3_[i_, ]))

        response[i_] ~ dnorm(y_[i_], sigma_[i_])
    }

where xi_ is a model matrix that is built R-side and x_ is par_x along which change points are defined. Implementing this adds the following work points:

Data structure

• Rename intercept: Intercept_i instead of int_i.
• Require par_x if there is not exactly one continuous predictor.
• Deicide parameter naming: stay close to lm and brms but add _segmentnumber.
• Split out RHS parameters from the segment table to a new long-format structure.
• Set appropriate priors. Distinguish between intercepts, dummies, and slopes?
• Raise error on rank deficiency using base::qr().

Modeling, sampling, and summaries

• Update get_formula() to match the new segment table.
• Update get_jagscode()
• Update run_jags() and get_jags_data() to work with design matrices. One per (dpar-segment) combo.
• Make sure that it applies for sigma(1 + x * group) etc. (I think it will out of the box).
• Verify that it works for plot_pars(), hypothesis(), summary(), fixef(), etc.
• get_summary(): Translate between code parameter name and user-facing parameter name.

Simulated, fitted, and predicted values

• Change args to fit$simulate(fit, data, par1, par2, ...), i.e., add fit and replace par_x with data.frame/tibble.
• Check that the columns in data have the correct format. Set factor levels to match the original data.
• Make fit$simulate() a wrapper around a lower-level fast function to use internally. Call it fit$.internal$simulate_vec(par_x, cp_1, ..., rhs_par1, rhs_par2, ...). Only the former should do asserts, call add_simulated(), etc.
• Implement for ar()
• Implement for varying change points.
• Call simulate_vectorized() from all internal functions instead of fit$simulate().
• Ensure that it works for fitted(), predict(), pp_check(), etc.
• Fix existing mcp_examples
• Add new mcp_examples?

Plot

• Allow faceting by any unique combination of (categorical) variables using plot(fit, facet_by = c("my_rhs", "my_varying_cp")). Still default to no facets.
• Control spaghetti groupings and colors using color_by = c("my_categorical1", "my_categorical2). It defaults to color_by = "all_categorical", i.e. all unique combinations of categorical levels on RHS. This will also set the grouping for spaghettis. I think that color_by should pertain solely to the RHS which share change points. Varying change points will not be accepted.
• Add a way to include a subset of the predictors: plot(fit, effects = "my_categorical1"). It's like brms::marginal_effects(). This should probably be implemented in tidy_samples().
• Display only a subset of the levels using plot(fit, filter = data.frame(my_categorical1 = c("levelA", "levelB"), my_categorical2 = "level1"). This is like brms::marginal_effects(), only filter using a data.frame replaces int_conditions which is a named list. For variables in effects that are not in filter, all levels will be included. This should probably be implemented in tidy_samples().
• (Add option to facet_by group levels in pp_check?)
• Add pages to plot_pars()

Tests

• Pass existing test suite.
• Write tests for combinations of main effects, factor-factor interactions, and factor-continuous interactions on ct, sigma, and ar. Also test the number of expected model parameters with and without intercepts.
• Expect errors on multiple terms inside base functions, e.g., ~exp(1 + x ).
• Test the new plot functions and tidy_draws()

options to print summary

Wondering if it is possible to have a switch argument to turn off the direct print from summary(fit)?

mcp/R/mcpfit_methods.R

Line 159 in ce4c50f

data.frame(result, row.names = NULL)

mcp/R/mcpfit_methods.R

Line 243 in ce4c50f

print(data.frame(result), digits = digits, row.names = FALSE)

Thank you

stan backend

mcp 2.0 will support stan in addition to JAGS. It is far out in the future but this issue collects working points.

• Obviously, generate a stan model, pass data, and sample it.
• Support bridgesampling-based Bayes Factors
• Can jags-functions and stan-functions be dropped as dependencies, only to be installed upon first use? (call mcp(model, data, backend = "stan")). Otherwise, the dependencies would be quite heavy for non-JAGS and non-stan users.
• Check if stan samples more effectively using a continuous step function, e.g., as in this post.
• Option or default to no prior for non-intercept and non-changepoint parameters? Cf. #122.

External validation of fits in unit test

Test accuracy of fits:

• Add strong priors so that parameter estimates are (should be) altered considerably.
• Validate parameter recovery in one-segment models against rstanarm, and loo and waic too.
• Validate parameter recovery in multi-segment models by letting rstanarm or lme4 fit individual segments and compare fits. If reasonably vague priors and reasonably well-defined change points are used, they should be practically identical.
• Plots: Check out the vdiffr package which ggplot2 uses.

Move rel() to priors

Implementing #90, I now see that rel() becomes cumbersome to support henceforth (it already was) and that it becomes somewhat ambiguous for categorical predictors. Users seem to misunderstand it anyway.

• Remove all code for rel()
• Add support for prior = list(groupX_2 = "groupX_1+ DEFAULT", catY_3 = "catY_1 + dnorm(0, 1) T(0, )"). The returned parameter should be the distribution part so the JAGS code needs to be like catY_1_return ~ dnorm(0, 1) T(0, ); catY_1 = catY_1 + catY_3
• Add explicit informative deprecation error if a user uses rel().
• Update code documentation
• Update vignettes

An advantage of this approach is that it expands functionality: allows relativity across segments (not just the former), it allows percentage-wise relativity (divide), etc.

Add "variance" argument to model sigma/ARMA/varying

There should be an mcp(..., sigma = ~ [formula]) argument to set it up for the whole model. The default should be mcp(..., sigma = ~ 1). The estimated sigma should just be called sigma instead of sigma_1. If any sigma() is specified in the segments, the mcp argument would apply up to that point, but the parameter would be called sigma_1, etc.

The downside is that it is redundant to specifying + sigma(1) in segment 1 (which is already the default if not done explicitly). Having two ways of doing the same thing is confusing.

I judge that the advantages outweigh this downside, though:

• it is congruent with other packages, e.g., brms and others.
• Less confusion because about whether it only applies to segment 1 or later ones
• Congruent with the implementation of upcoming functions, like the upcoming mcp(..., autocor).

One thing to decide:

• Should it be sigma = ~ 1 or sigma = ~ sigma(1)? The latter is more verbose, but more consistent with usage in the formulas and the upcoming autocor.

Add summary.mcpfit and fitted.mcpfit

Look to brms for inspiration

• Simple summary(fit)
• Proper summary(fit) with info about model, convergence, etc.
• fitted(fit). This is already done in plot,mcpfit. Could also be predict(fit)
• ranef(fit) would also be nice.

Update plot.mcpfit and add fit$func

It currently draws using the fitted values y_[i]. This bloats the fit$samples and is very slow in every way.

Instead, we need to make a function which respects fit$segments like

fit$func = function(x, cp_1, int_1. x_1, x_2) {
    ...
}

... and use that for plotting and possibly prediction by running it for some/all MCMC draws. The fit$func may be useful for other purposes as well.

Observation weights

I have got a list of observations along a spatial axis, that I would like to fit a simple intercept model to (as described here).

However, I am not equally confident in all of my observations, so I would like to add weights to account for uncertainty. I could do this for instance with ecp::e.divisive.

Is this something you are considering for mcp as well?

Otherwise, there is of course the possibility to explicitly model the generative process in JAGS, but that would remove the convenience of mcp.

EnvCpt clarification

I was happy to see that EnvCpt is included in your comparison documentation, thanks for including it.

In a couple of places you write "I suspect EnvCpt uses cpt.np() in the background" for the change in mean parts. I wanted to clarify that it is using cpt.meanvar() from the changepoint package. You will see that the changepoint.np package is not a dependency and therefore it could not use this in the background.

This explains the differences you see between EnvCpt and the cpt.mean() function.

Is there a "predict" function?

It seems there isn't a "predict" function. Please correct me if I'm wrong?

I think the predicted values would be generated from the model parameters in the last segment, correct?

Predictions for unobserved change points

As discussed in the last part of this article mcp can be "hacked" to model change points in regions with no data. This is useful when forecasting. A more user-friendly API should be included.

This is a spin-off of #78 where some details are already discussed.

Add vignettes

The README is growing quite big. Write more focused vignettes and link to them:

• Typical workflow (probably in README.md?)
• Understanding the theory and models by inspecting fit$func_y and fit$jags_code.
• Binomial
• Poisson
• Priors,
• Varying effects.

plot() method for type = "overlay" not working

I suspect this has to do with tidybayes version.

Reprex below.

library(mcp)

my_data <- data.frame(
  x = 1:50,
  y = c(
    rep(30, 25) * abs(rnorm(25)),
    rep(30, 25) * -abs(rnorm(25))
  )
)

# Define segments
segments <- list(
  y ~ 1 + x, # Intercept
  1 ~ 1 # Intercept
)

# Start sampling
fit <- mcp(segments, my_data, cores = 1)
#> Compiling data graph
#>    Resolving undeclared variables
#>    Allocating nodes
#>    Initializing
#>    Reading data back into data table
#> Compiling model graph
#>    Resolving undeclared variables
#>    Allocating nodes
#> Graph information:
#>    Observed stochastic nodes: 50
#>    Unobserved stochastic nodes: 5
#>    Total graph size: 631
#> 
#> Initializing model
#> 
#>    user  system elapsed 
#>     2.2     0.5     2.7

summary(fit)
#> Warning: unnest() has a new interface. See ?unnest for details.
#> Try `df %>% unnest(c(.lower, .upper))`, with `mutate()` if needed
#> # A tibble: 5 x 4
#>   name     mean .lower  .upper
#>   <chr>   <dbl>  <dbl>   <dbl>
#> 1 cp_1   25.5    24.0   27.0  
#> 2 int_1  21.4     7.54  35.1  
#> 3 int_2 -24.4   -31.2  -17.7  
#> 4 sigma  16.9    13.3   20.5  
#> 5 x_1    -0.354  -1.29   0.652

# Plot fit
plot(fit)
#> Error in spread_draws_long_(tidy_draws(model), variable_names, dimension_names, : No variables found matching spec: draws

plot(fit, "combo")

plot(fit, "overlay")
#> Error in spread_draws_long_(tidy_draws(model), variable_names, dimension_names, : No variables found matching spec: draws

packageVersion("tidybayes")
#> [1] '1.1.0'

Ideas for the far future

Here are some ideas which could use some discussion and careful consideration. It extends the current model specification: https://lindeloev.github.io/mcp/articles/formulas.html

In the order from "soonish" (top) to "in your dreams":

Survival models

Survival models are relatively simple and we should support them, including censoring too. The API for the model itself would be something like brms:

model = list(
    eventtime | cens(status) ~ 0,
    ~ 0 + x
)

It should support both exponential decay and Cox proportional hazards. This would probably be specified via the mcp(..., family = ) argument, but I'm unsure what would be the best.

Slope on change points

If there are multiple (piecewise) lines over a single change point, and each line is associated with a different parameter x, we can use that to predict the change point. For example, we could assess subitizing in participants of varying age, and it would be reasonable to expect the subitizing range (location of first change point) to increase with age in childhood and decrease with age in adulthood.

How to implement this in a formula, I'm unsure. Maybe it has to be in the random effect: (1 + x | age) since that specifies the grouping of multiple lines. This would also ensure that the parameter names stay intact. cp_i, cp_i_age, and then probably cp_i_x.

Multivariate regression

Multiple response variables predicted from single change points. Something like

model = list(
    c(y1, y2) ~ 1 + x,  # segment 1
    ~ 0  # seg2: joined intercept
)

This could be merged with "Variance change (Specify y)" to specify a change in one response but not the other:

model = list(
    c(y1, y2) ~ 1 + x,  # segment 1
    ~ 0  # seg2: joined intercept on y1 and y2, segment 2
    y1 ~ 1 ~ x  # seg3: slope change in y1 but not y2
)

ARIMA

mcp currently supports AR(N) models. It should go more general. Take a look at:

• https://www.apress.com/gp/blog/all-blog-posts/simulating-autoregressive-and-moving-average-time-series-in-r/16711624
• https://github.com/andrewcparnell/jags_examples

Make a prior predictive plot

This should be fairly simple to do. Just run the JAGS model without data and the predictive formula, and collect samples. Two ideas:

mcp(segments, data = "prior")

Although philosophically sound (the prior acts in the same way as data), it does look kind of weird. Another option is to take a dedicated argument like brms::brm:

mcp(segments, sample_prior = TRUE)

Perhaps these samples should be stored in fit$prior_samples. Down the line, they could be useful for computing Bayes Factors of point-null models.

I discarded a third option immediately, because users who forget to provide data would get very confused that the model "ignores" it. The idea is to take the lack of a data argument to mean that only priors should be sampled (because sample == TRUE by default)

mcp(segments)

Update package overview

The overview should include the yet-to-be-reviewed/tested packages mentioned at the top, and perhaps an additional example: https://lindeloev.github.io/mcp/articles/packages.html.

Also update:

• strucchange::breakpoints does take time series and returns confidence intervals on the break points.
• changepoint.geo. It reduces multivariate problems to angle+length in vector space, and calls cpt.mean and cpt.var on this using PELT. So it's changepoint but with a tweak to allow for high-dimensional data.
• Searching for "change detection" yields a set of new packages, e.g., changedetection.

Parameterize JAGS dnorm/dcauchy priors with SD instead of precision

JAGS uses precision (1/sigma^2) instead of SD as the spread parameter in dnorm, dcauchy, and dt. This is confusing. Allow users to specify using SD instead:

prior = list(
    cp_1 = "dnorm(10, 5)",
    int_2 = "dcauchy(1, 0.2)"
)

should generate JAGS code

cp_1 ~ dnorm(10, 1/5^2)
int_2 ~ dcauchy(1, 1/0.2^2)

If users want to specify precision, they can do this:

prior = list(
    cp_1 = "dnorm(10, sqrt(1/5))",
    int_2 = "dcauchy(1, sqrt(1/0.2))"
)

Fixed values

Add the functionality to fix some parameter values rather than having them inferred. Since this is just a 100% prior of a certain value, this should be done in prior. They have to be numerical values.

prior = list(
  int_1 = "dnorm(0, 1)",
  cp_1 = 10,
  int_2 = 20,
  cp_2 = "dnorm(40, 10) T(cp_1, )"
)

mcp(segments, data, prior)

I think it should still be included in summaries, just so that they always express the full model.

Random effects in RHS

Include optional random effects for all parameters. Here is a great guide for JAGS and stan

Or add a varying slope too:

list(y~ 1 + x, 
      (1|id) ~ 0 + (1|x))

Keep it intercept-only at first with uncorrelated random effects. Think about whether to allow for fixed and random of the same parameter (mean-centering random):

list(y~ 1 + x, 
      1 + (1|id) ~ 0 + x+ (1|x))

Support simulating and visualizing autocorrelation

Update fit$func_y to support simulating and predicting autocorrelations. Update plot.mcpfit() appropriately too, including intervals.

Rename `ranef` to `ranef.mcpfit`

Hi!
I was wondering if you could help me with this. When I run this code:

model = list(
acc | trials(N) ~ 1,
1 + (1|id) ~ 0 + numerosity)

fit<- mcp(model, data = df, family = binomial())
summary(fit)
ranef(ift)

I get the following error:

Error in UseMethod("ranef") :
no applicable method for 'ranef' applied to an object of class "mcpfit"

Before that I tried using the following code with a slightly different dataset so I could use the bernoulli family:

model = list(
acc ~ 1,
1 + (1|id) ~ 0 + numerosity
)

fit<- mcp(model, data = df, family = bernoulli())
summary(fit)
ranef(ift)

I got the same error.

Thanks in advance!!

Compute loglik post-hoc

log-likelihood is currently computed during sampling. This is >90% of the size of the fit object and may slow sampling too. It's only used for loo and waic so WWBD (What Would brms Do)?:

• Remove computation of loglik during sampling.
• Add method fit = mcp::add_loglik(fit) which fills fit$loglik with a (Nchains*Nsample) x Ndata matrix
• Call add_loglik in loo and waic if is.null(fit$loglik)
• Update all documentation

joined slopes not working

Reprex below.

Should user initialize where the changepoint may be in the data?

library(mcp)

my_data <- data.frame(x = 1:50,
                      y = c(1:25 * 3 + abs(rnorm(25)),
                            1:25 * -3 + abs(rnorm(25) + 75)))

plot(x = my_data$x, y = my_data$y)

segments = list(
  y ~ 1 + x,  # intercept + slope
  1 ~ 0 + x  # joined slope
)

fit = mcp(segments, my_data, cores = 1)
#> Compiling data graph
#>    Resolving undeclared variables
#>    Allocating nodes
#>    Initializing
#>    Reading data back into data table
#> Compiling model graph
#>    Resolving undeclared variables
#>    Allocating nodes
#> Deleting model
#> Error in rjags::jags.model(model, data, n.chains = n.chains, n.adapt = n.adapt, : RUNTIME ERROR:
#> Compilation error on line 39.
#> Unknown variable cp_2
#> Either supply values for this variable with the data
#> or define it  on the left hand side of a relation.

^{Created on 2019-10-27 by the reprex package (v0.2.1)}

NB support

Hi there,
Can I use glm.nb for the regression?
Thank you!

Increase resolution of plot.mcpfit around change points

#42 show how the current resolution of default plots can be confusing. Simply make eval_at finer around change points. Or fall back on adding a resolution argument to plot.mcpfit.

Implement MA(N), AR(N), and ARMA(N)

This should be possible:

• mcp(..., variance = ~ ma(1)). Parameter will be named ma1.
• mcp(..., variance = ~ ar(3)). Parameters will be named ar1, ar2, ar3
• mcp(..., variance = ~ arma(2)); same as mcp(..., variance = ~ ma(2) + ar(2). Parameters will be named ma1, ma2, ar1, ar2.

As with other effects in #56, it would apply to the whole model.

Memory-efficient loo(fit)

Implement by-data-row computation of LOO cf. this request by @mattmoo: #109.