Step 0: Load package and data

First, we load the goldfish package and load the data. The data is loaded using lazy loading, i.e., the objects are only ‘promised’ for the moment, but are available in the environment to be used, and more information will appear as you use them. You can find out more about this dataset, its format, and its origins in a couple of ERGM papers by callings its documentation:

{r load, message=FALSE} library(goldfish) data("Social_Evolution") # ?Social_Evolution head(calls) head(actors)

```{r mask, echo=FALSE} #| purl = FALSE estimate <- function( x, model = c(“DyNAM”, “REM”, “DyNAMi”), subModel = c(“choice”, “rate”, “choice_coordination”), estimationInit = NULL, preprocessingInit = NULL, preprocessingOnly = FALSE, verbose = FALSE, silent = TRUE, debug = FALSE) {

if (is.null(estimationInit$engine)) { estimationInit <- c(estimationInit, list(engine = “gather_compute”)) }

goldfish::estimate( x = x, model = model, subModel = subModel, estimationInit = estimationInit, preprocessingInit = preprocessingInit, preprocessingOnly = preprocessingOnly, verbose = verbose, silent = silent, debug = debug ) }

# Preamble: Run a quick DyNAM in five lines
We use `R` version 4.2.0 to compile the vignettes.
The native pipe operator is available in `R` from version 4.1.0.

```{r quick}
callNetwork <- defineNetwork(nodes = actors, directed = TRUE) |> # 1
  linkEvents(changeEvent = calls, nodes = actors) # 2

# 3
callsDependent <- defineDependentEvents(
  events = calls, nodes = actors,
  defaultNetwork = callNetwork
  )

# 4
mod00Rate <- estimate(
  callsDependent ~ indeg + outdeg,
  model = "DyNAM", subModel = "rate"
  )

summary(mod00Rate)

mod00Choice <- estimate(
  callsDependent ~ inertia + recip + trans,
  model = "DyNAM", subModel = "choice"
  )

summary(mod00Choice)

Step 1: Create data objects

The network at half time

callNetworkHlf <- as.matrix(callNetwork, time = calls\(time[floor(nrow(calls) / 2)]) |> add_node_attribute("floor", actors\)floor)

autographr(callNetworkHlf, labels = FALSE, layout = “fr”) + geom_node_point(aes(color = as.factor(floor)), size = 2, show.legend = FALSE)

The network at the end

callNetworkEnd <- as.matrix(callNetwork, time = max(calls\(time) + 1) |> add_node_attribute("floor", actors\)floor)

autographr(callNetworkEnd, labels = FALSE, layout = “fr”) + geom_node_point(aes(color = as.factor(floor)), size = 2, show.legend = FALSE)

The tie strength at the end

table(as.matrix(callNetwork, time = max(calls$time) + 1))

# Step 2: Specify and estimate model

The second step is to specify and fit a model to this data. 
This step can be broken up into several stages:

-   **Step 2a**. *Formula*: Specify a model formula from the effects and variables available

-   **Step 2b**. *Preprocessing*: Calculate the change statistics associated with these effects

-   **Step 2c**. *Estimation*: Fit an appropriate model to these statistics

However, in goldfish we also have the option of accelerating this process and using memory more efficiently by combining these three sub-steps in one. 
Nonetheless, it can be helpful to think of 2a separately, and recognize steps 2b and 2c as goldfish does them.

## Step 2a. Formula

We specify our model using the standard R formula format like:

`goldfish_dependent ~ effects(process_state_element)`

We can see which effects are currently available and how to specify them here:

```{r effects, eval=FALSE}
vignette("goldfishEffects")

Let’s start with the simplest model we can imagine:

{r simple-formula} simpleFormulaChoice <- callsDependent ~ tie(friendshipNetwork)

What are we testing here? Do individuals call their friends more than non-friends?

### Rate model

How do individual properties affect the rate of action of individuals? (Step 1 of the model)

Let us again define a simple formula that only depends on individuals' degree in the friendship network

```{r simple-rate}
simpleFormulaRate <- callsDependent ~ indeg(friendshipNetwork)
mod01Rate <- estimate(
  simpleFormulaRate,
  model = "DyNAM", subModel = "rate"
  )

#### Right-censored intervals

Recall that it is important to add a time intercept when estimating models with
right-censored intervals (as discussed in Stadtfeld & Block, 2017). 
Adding an intercept is as easy as including a 1 to the formula:

```{r intcpt-rate}
interceptFormulaRate <-
  callsDependent ~ 1 + indeg(callNetwork) + outdeg(callNetwork) +
                   indeg(friendshipNetwork)

mod03Rate <- estimate(interceptFormulaRate, model = "DyNAM", subModel = "rate")
summary(mod03Rate)

But what if it is not just a random call?

Expected waiting time of those who have five outgoing call ties (five different actors)

1 / exp( mod03RateCoef[[“Intercept”]] + mod03RateCoef[[“outdeg”]] * 5 ) / 3600 # Expected waiting time of those who have five outgoing and incoming call ties (five different actors) 1 / exp( mod03RateCoef[[“Intercept”]] + mod03RateCoef[[“outdeg”]] * 5 + mod03RateCoef[[“indeg”]] * 5 ) / 3600

### Windows

Remember our `callNetwork` process state accumulates actions in time, but some older actions may no longer be relevant to current action. 
Let's see whether it is really just recent partners that matter by adding extra effects with a window of... how long? 
Let us try 5 minutes $= 5 * 60 = 300s$

```{r windows-rate}
windowFormulaRate <-
  callsDependent ~ 1 + indeg(callNetwork) + outdeg(callNetwork) +
                   indeg(callNetwork, window = 300) +
                   outdeg(callNetwork, window = 300) +
                   indeg(friendshipNetwork)

mod04Rate <- estimate(windowFormulaRate, model = "DyNAM", subModel = "rate")
summary(mod04Rate)

Of course, you can also add windows to the choice formula!

```{r windows-choice, eval = FALSE} windowFormulaChoice <- callsDependent ~ inertia(callNetwork) + recip(callNetwork) + inertia(callNetwork, window = 300) + recip(callNetwork, window = 300) + tie(friendshipNetwork) + recip(friendshipNetwork) + same(actors\(gradeType) + same(actors\)floor)

mod03Choice <- estimate(windowFormulaChoice, model = “DyNAM”, subModel = “choice”) summary(mod03Choice)

```{r windows-choiceR, echo = FALSE}
windowFormulaChoice <-
  callsDependent ~ inertia(callNetwork) + recip(callNetwork) +
                   inertia(callNetwork, window = 300) +
                   recip(callNetwork, window = 300) +
                   tie(friendshipNetwork) + recip(friendshipNetwork) +
                   same(actors$gradeType) + same(actors$floor)

mod03Choice <- estimate(windowFormulaChoice,
                         model = "DyNAM", subModel = "choice",
                         estimationInit = list(engine = "default"))
summary(mod03Choice)

All this shows you that you can specify different formula for the rate and choice components of the model. This is a key advantage of the DyNAM!

When comparing the information criteria (AIC / BIC) of the different model, we see that the time windows explain a lot

{r aic} AIC(mod02Choice) AIC(mod03Choice) AIC(mod03Rate) AIC(mod04Rate)

```{r rem-c}
mod01REM <- estimate(
  allFormulaREM, model = "REM",
  estimationInit = list(initialDamping = 40, engine = "default_c")
  )

summary(mod01REM)