fit_model {disaggregation} | R Documentation |

*fit_model* function takes a *disag_data* object created by
`prepare_data`

and performs a Bayesian disaggregation fit.

```
fit_model(
data,
priors = NULL,
family = "gaussian",
link = "identity",
iterations = 100,
field = TRUE,
iid = TRUE,
hess_control_parscale = NULL,
hess_control_ndeps = 1e-04,
silent = TRUE
)
disag_model(
data,
priors = NULL,
family = "gaussian",
link = "identity",
iterations = 100,
field = TRUE,
iid = TRUE,
hess_control_parscale = NULL,
hess_control_ndeps = 1e-04,
silent = TRUE
)
```

`data` |
disag_data object returned by |

`priors` |
list of prior values |

`family` |
likelihood function: |

`link` |
link function: |

`iterations` |
number of iterations to run the optimisation for |

`field` |
logical. Flag the spatial field on or off |

`iid` |
logical. Flag the iid effect on or off |

`hess_control_parscale` |
Argument to scale parameters during the calculation of the Hessian.
Must be the same length as the number of parameters. See |

`hess_control_ndeps` |
Argument to control step sizes during the calculation of the Hessian.
Either length 1 (same step size applied to all parameters) or the same length as the number of parameters.
Default is 1e-3, try setting a smaller value if you get NaNs in the standard error of the parameters.
See |

`silent` |
logical. Suppress verbose output. |

**The model definition**

The disaggregation model makes predictions at the pixel level:

`link(pred_i) = \beta_0 + \beta X + GP(s_i) + u_i`

And then aggregates these predictions to the polygon level using the weighted sum (via the aggregation raster, `agg_i`

):

`cases_j = \sum_{i \epsilon j} pred_i \times agg_i`

`rate_j = \frac{\sum_{i \epsilon j} pred_i \times agg_i}{\sum_{i \epsilon j} agg_i}`

The different likelihood correspond to slightly different models (`y_j`

is the response count data):

Gaussian: If

`\sigma`

is the dispersion of the pixel data,`\sigma_j`

is the dispersion of the polygon data, where`\sigma_j = \sigma \sqrt{\sum agg_i^2} / \sum agg_i`

`dnorm(y_j/\sum agg_i, rate_j, \sigma_j)`

- predicts incidence rate.

Binomial: For a survey in polygon j,

`y_j`

is the number positive and`N_j`

is the number tested.`dbinom(y_j, N_j, rate_j)`

- predicts prevalence rate.

Poisson:

`dpois(y_j, cases_j)`

- predicts incidence count.

Specify priors for the regression parameters, field and iid effect as a single list. Hyperpriors for the field
are given as penalised complexity priors you specify `\rho_{min}`

and `\rho_{prob}`

for the range of the field
where `P(\rho < \rho_{min}) = \rho_{prob}`

, and `\sigma_{min}`

and `\sigma_{prob}`

for the variation of the field
where `P(\sigma > \sigma_{min}) = \sigma_{prob}`

. Also, specify pc priors for the iid effect

The *family* and *link* arguments are used to specify the likelihood and link function respectively.
The likelihood function can be one of *gaussian*, *poisson* or *binomial*.
The link function can be one of *logit*, *log* or *identity*.
These are specified as strings.

The field and iid effect can be turned on or off via the *field* and *iid* logical flags. Both are default TRUE.

The *iterations* argument specifies the maximum number of iterations the model can run for to find an optimal point.

The *silent* argument can be used to publish/suppress verbose output. Default TRUE.

A list is returned of class `disag_model`

.
The functions *summary*, *print* and *plot* can be used on `disag_model`

.
The list of class `disag_model`

contains:

`obj` |
The TMB model object returned by |

`opt` |
The optimized model object returned by |

`sd_out` |
The TMB object returned by |

`data` |
The |

`model_setup` |
A list of information on the model setup. Likelihood function ( |

Nanda et al. (2023) disaggregation: An R Package for Bayesian Spatial Disaggregation Modeling. <doi:10.18637/jss.v106.i11>

```
## Not run:
polygons <- list()
for(i in 1:100) {
row <- ceiling(i/10)
col <- ifelse(i %% 10 != 0, i %% 10, 10)
xmin = 2*(col - 1); xmax = 2*col; ymin = 2*(row - 1); ymax = 2*row
polygons[[i]] <- rbind(c(xmin, ymax), c(xmax,ymax), c(xmax, ymin), c(xmin,ymin))
}
polys <- do.call(raster::spPolygons, polygons)
response_df <- data.frame(area_id = 1:100, response = runif(100, min = 0, max = 10))
spdf <- sp::SpatialPolygonsDataFrame(polys, response_df)
r <- raster::raster(ncol=20, nrow=20)
r <- raster::setExtent(r, raster::extent(spdf))
r[] <- sapply(1:raster::ncell(r), function(x) rnorm(1, ifelse(x %% 20 != 0, x %% 20, 20), 3))
r2 <- raster::raster(ncol=20, nrow=20)
r2 <- raster::setExtent(r2, raster::extent(spdf))
r2[] <- sapply(1:raster::ncell(r), function(x) rnorm(1, ceiling(x/10), 3))
cov_rasters <- raster::stack(r, r2)
cl <- parallel::makeCluster(2)
doParallel::registerDoParallel(cl)
test_data <- prepare_data(polygon_shapefile = spdf,
covariate_rasters = cov_rasters)
parallel::stopCluster(cl)
foreach::registerDoSEQ()
result <- fit_model(test_data, iterations = 2)
## End(Not run)
```

[Package *disaggregation* version 0.2.1 Index]