Overview

netify is an R package for working with relational data. It converts edge lists, matrices, and data frames into network objects that you can analyze and visualize using a consistent set of functions.

We built netify while doing our own network research in social science. It handles common tasks like temporal network analysis, ego network extraction, and multiplex relationships without requiring multiple packages or data format conversions.

Installation

Install the package from CRAN after release:

install.packages("netify")

Install the development version from GitHub:

install.packages("devtools")
devtools::install_github("netify-dev/netify", dependencies = TRUE)

Quick Start

Transform your relational data into a network object with just one function:

library(netify)
data(icews)
# Create a network from dyadic data
icews_conflict <- netify(
  icews,
  actor1 = 'i',
  actor2 = 'j',
  time = 'year',
  symmetric = FALSE,
  weight = 'matlConf',
  nodal_vars = c('i_polity2', 'i_log_gdp', 'i_region')
)
# Print the netify object
print(icews_conflict)

✔ Network data created.
• Unipartite
• Asymmetric
• Weights from `matlConf`
• Longitudinal: 13 Periods
• # Unique Actors: 152
Network Summary Statistics (averaged across time):
          dens miss   mean recip trans
matlConf 0.113    0 12.997 0.594 0.387
• Nodal Features: i_polity2, i_log_gdp, i_region
• Dyad Features: None

Quick visualization

# Plot the network
plot(icews_conflict)

Add node color

You can map node attributes to plot aesthetics:

# Create democracy indicator
icews$i_democ <- factor(
  ifelse(icews$i_polity2 >= 6, 1, 0),
  levels = c(0, 1),
  labels = c("Non-democracy", "Democracy")
)
# Add it to the network
icews_conflict <- add_node_vars(
  icews_conflict, icews,
  actor = 'i', time = 'year',
  node_vars = 'i_democ'
)
plot(
  icews_conflict,
  # Log transform weights
  mutate_weight = log1p,
  # Map node attributes to aesthetics
  node_color_by = 'i_region',
  node_size_by = 'i_log_gdp',
  node_shape_by = 'i_democ',
  # set global node alpha
  node_alpha = .7,
  # set global edge alpha
  edge_linewidth = .1,
  # Filter data
  node_filter = ~ !is.na(i_democ),
  time_filter = c('2002', '2004', '2008', '2014'),
  # clean up plot labels
  edge_alpha_label = 'Log(Matl.\n Conf.)',
  node_color_label = '',
  node_size_label = 'Log(GDP)',
  node_shape_label = ''
  ) +
  ggplot2::theme(legend.position = 'right') +
  ggplot2::scale_color_brewer(palette = 'Set1')

What can you do with a netify object?

Get network statistics

summary(icews_conflict)

This returns a data frame with network statistics for each time period:

(Table shows first few rows - actual output includes all time periods)

Key functions

Building networks

• netify() - Turn your data into a network object
• ego_netify() - Extract ego networks
• layer_netify() - Stack multiple relationships into multilayer networks

Adding information

• add_node_vars() - Attach attributes to actors (like GDP, democracy scores)
• add_dyad_vars() - Attach attributes to relationships (like trade volume, conflict events)

Wrangling networks

• subset() - Pull out specific time periods or actors
• mutate_weights() - Log-transform, normalize, or otherwise modify edge weights

Analysis

• measurements() - Measurements of your network size and composition
• summary() - Get a quick overview of your network
• summary_actor() - See how individual actors fit into the network
• compare_networks() - See how similar two networks are
• homophily() - Do similar actors tend to connect?
• mixing_matrix() - Who connects with whom?

Visualization

• plot() - Create network diagrams with sensible defaults
• plot_actor_stats() - Visualize node-level statistics
• plot_graph_stats() - Show how network properties change over time

Working with other packages

• to_igraph() / to_network() - When you need something we don't have
• to_amen() - For fitting AME or SRM models
• unnetify() - Get back to a regular data frame

Quick Reference

Essential Functions

Scaling to large networks

netify stores adjacencies as dense matrices/arrays, which keeps the API uniform but makes memory the binding constraint at large N (a single dense N x N slice costs 8 * N^2 bytes; e.g. ~7.6 MB at N=1K, ~191 MB at N=5K, and ~1.7 GB at N=15K). A few knobs and benchmarks to keep in mind:

• Sparse matrix guard. Passing a Matrix::sparseMatrix (e.g. dgCMatrix) to netify() densifies internally. When N > 5000 and density is under 1%, netify() aborts with a guidance message rather than silently allocating gigabytes. Override with force_dense = TRUE if you really want the dense object, or build from an edgelist data.frame to skip the matrix intermediate entirely.
• Fast actor stats. summary_actor() defaults to stats = "all" (degree + closeness + betweenness + eigenvector + HITS). The closeness/betweenness paths dominate wall-clock at large N, so at N >= getOption("netify.fast_threshold", 1500L) netify auto-promotes the default call to stats = "fast", which returns only the degree- and strength-style columns. Pass stats = "all" explicitly to force centralities, or raise the threshold via options(netify.fast_threshold = ...).
• Indicative timings (single laptop core, directed weighted toy nets):

For 10K+ actor / weekly-slice workflows, prefer edgelist inputs, set stats = "fast" explicitly, and consider to_igraph() for any heavy centrality work.

When you might need something else

netify covers common network data workflows and provides converters for specialized packages when you need methods outside its scope:

• Statistical models: Use to_amen() for latent factor models or to_statnet() for ERGMs
• Graph algorithms: Convert with to_igraph() to use igraph methods
• Custom analysis: Use unnetify() to return to a data frame

These converters let you move between netify and other network-analysis tools without rebuilding the data by hand.

Getting help

• Browse installed vignettes with browseVignettes("netify"); additional workflow articles are on the package website.
• Check function documentation: ?netify, ?plot.netify, etc.
• Report bugs: GitHub Issues

Citation

If you use netify in your research, please cite:

citation("netify")

Contributors

netify is developed by:

• Cassy Dorff (Vanderbilt University)
• Shahryar Minhas (Michigan State University)

With contributions from:

• Ha Eun Choi (Michigan State University)
• Colin Henry (Vanderbilt University)
• Tosin Salau (Michigan State University)

This work is supported by National Science Foundation Awards #2017162 and #2017180.

License

GPL-3

Made for the network analysis community