bhpm.pm {bhpm} | R Documentation |

Implementation of a bayesian Hierarchical for grouped data and clusters with Point-Mass.

```
bhpm.pm(cluster.data, hier = 3, sim_type = "SLICE", burnin = 20000,
iter = 60000, nchains = 5, theta_algorithm = "MH",
global.sim.params = NULL,
sim.params = NULL,
monitor = NULL,
initial_values = NULL, level = 1, hyper_params = NULL,
global.pm.weight = 0.5,
pm.weights = NULL,
adapt_phase=1, memory_model = "HIGH")
```

`cluster.data` |
A file or data frame containing the cluster data. It must contain the columns |

`hier` |
Fit a 2 or 3 level model. |

`burnin` |
The burnin period for the monte-carlo simulation. These are discarded from the returned samples. |

`iter` |
The total number of iterations for which the monte-carlo simulation is run. This includes the burnin period.
The total number of samples returned is |

`nchains` |
The number of independent chains to run. |

`theta_algorithm` |
MCMC algorithm used to sample the theta variables. "MH" is the only currently supported stable algorithm. |

`sim_type` |
The type of MCMC method to use for simulating from non-standard distributions apart from theta. Allowed values are |

`monitor` |
A dataframe indicating which sets of variables to monitor. Passing NULL uses the model defaults. |

`global.sim.params` |
A data frame containing the parameters for the simuation type |

`sim.params` |
A dataframe containing simulation parameters which override the global simulation parameters ( The function |

`initial_values` |
The initial values for starting the chains. If NULL (the default) is passed the function generates the initial values for the chains. initial_values is a list with the following format: list(gamma, theta, mu.gamma, mu.theta, sigma2.gamma, sigma2.theta, pi, mu.gamma.0, mu.theta.0, tau2.gamma.0, tau2.theta.0, alpha.pi, beta.pi) The function |

`level` |
Allowed valus are 0, 1, 2. Respectively these indicate independent clusters, common means across the clusters and weak relationships between the clusters. |

`hyper_params` |
The hyperparameters for the model. Passing NULL uses the model defaults. |

`global.pm.weight` |
A global weighting for the proposal distribution used to sample theta. |

`pm.weights` |
Override global.pm.weight for specific outcomes. |

`adapt_phase` |
Unused parameter. |

`memory_model` |
Allowed values are "HIGH" and "LOW". "HIGH" means use as much memory as possible. "LOW" means use the minimum amount of memory. |

The model is fitted by a Gibbs sampler.

The output from the simulation including all the sampled values is as follows:

list(id, theta_alg, sim_type, chains, nClusters, Clusters, nOutcome.Grp, maxOutcome.Grps, maxOutcomes, nAE, AE, B, burnin, iter, monitor, mu.gamma.0, mu.theta.0, tau2.gamma.0, tau2.theta.0, mu.gamma, mu.theta, sigma2.gamma, sigma2.theta, pi, alpha.pi, beta.pi, alpha.pi_acc, beta.pi_acc, gamma, theta, gamma_acc, theta_acc)

where

*id* - a string identifying the verions of the function.

*theta_alg* - an string identifying the algorithm used to smaple theta.

*sim_type* - an string identifying the samlping method used for non-standard distributions, either *"MH"* or *"SLICE"*.

*chains* - the number of chains for which the simulation was run.

*nClusters* - the number of clusters in the simulation.

*Clusters* - an array. The clusters.

*nOutcome.Grp* - the number of outcome groupings.

*maxOutcome.Grps* - the maximum number of outcome groupings in a cluster.

*maxOutcomes* - the maximum number of outcome in a outcome grouping.

*nOutcome* - an array. The number of outcomes in each outcome grouping.

*Outcome* - an array of dimension *nOutcome.Grp*, *maxOutcomes*. The outcomes.

*Outcome.Grp* - an array. The outcome groupings.

*burnin* - burnin used for the simulation.

*iter* - the total number of iterations in the simulation.

*monitor* - the variables being monitored. A dataframe.

*mu.gamma.0* - array of generated samples.

*mu.theta.0* - array of generated samples.

*tau2.gamma.0* - array of generated samples.

*tau2.theta.0* - array of generated samples.

*mu.gamma* - array of generated samples.

*mu.theta* - array of generated samples.

*sigma2.gamma* - array of generated samples.

*sigma2.theta* - array of generated samples.

*pi* - array of generated samples.
*alpha.pi* - array of generated samples.
*beta.pi* - array of generated samples.

*alpha.pi_acc* - the acceptance rate for the alpha.pi samples if a Metropolis-Hastings method is used.

*beta.pi_acc* - the acceptance rate for the beta.pi samples if a Metropolis-Hastings method is used.

*gamma* - array of generated samples.

*theta* - array of generated samples.

*gamma_acc* - the acceptance rate for the gamma samples if a Metropolis-Hastings method is used.

*theta_acc* - the acceptance rate for the theta samples.

The function performs the simulation and returns the raw output. No checks for convergence are performed.

R. Carragher

```
data(bhpm.cluster.data1)
raw = bhpm.pm(cluster.data = bhpm.cluster.data1, burnin = 100, iter = 200)
data(bhpm.cluster.data1)
raw = bhpm.pm(cluster.data = bhpm.cluster.data1)
```

[Package *bhpm* version 1.7 Index]