add curaction scripts

src/00_setup_curation.sh

@@ -0,0 +1,24 @@
+
+
+# from a base directory
+
+
+mkdir data
+mkdir intermeidate
+mkdir product
+
+cd product
+git clone https://huggingface.co/RosettaCommons/MIP
+cd ..
+
+# Run each numbered script in product/MIP/src/ in order (starting with this one)
+#
+# Tips:
+#    1) Make sure to set the working directory to the base directory (outside of the HF repo)
+#    2) While most of the scripts should work, I recommend running them interactively
+#    3) Some stages require more memory than others, all can be done with < 400GB of memory
+#       but perhaps more more could reduce memory requirements
+#    4) 
+
+
+

src/01_gather_data.R

@@ -0,0 +1,17 @@
+
+
+# Download data from: https://zenodo.org/records/6611431
+# Sequence-structure-function relationships in the microbial protein universe
+
+# 45.4 GB
+system("cd data && curl -o microbiome_immunity_project_dataset.zip https://zenodo.org/records/6611431/files/microbiome_immunity_project_dataset.zip?download=1")
+
+md5sum_expected <- "b3e021609ffa052d2ab2333dc998964b  data/microbiome_immunity_project_dataset.zip" 
+md5sum <- system(
+    "md5cksum data/microbiome_immunity_project_dataset.zip",
+    intern = TRUE)
+if (md5sum != md5sum_expected) {
+    cat("Expected and obtained md5sum values don't match\n")
+}
+
+system("cd data && unzip microbiome_immunity_project_dataset.zip")

src/02.1_assemble_datasets.R

@@ -0,0 +1,250 @@
+
+
+
+#' Assemble a Rosetta models dataset
+#'
+#' @param data_path character directory .pdb.gz files are located
+#' @param output_path character output .parquet path
+#'
+#' Write output_path .parquet file with columns
+#'   <id> <pdb> [<scores>]
+#' where [<scores>] are key-value entries following
+#' the TER line in each .pdb.gz file
+assemble_rosetta_models <- function(
+    data_path,
+    output_path) {
+
+    cat(
+        "data path: ", data_path, "\n",
+        "output path: ", output_path, "\n",
+        sep = "")
+
+    file_index <- 1
+    models <- list.files(
+        path = data_path,
+        full.names = TRUE,
+        pattern = "*.pdb.gz",
+        recursive = TRUE) |>
+        purrr::map_dfr(.f = function(path) {
+            file_handle <- path |>
+                file(open = "rb") |>
+                gzcon()
+
+            if( file_index %% 1000 == 0) {
+                cat("Reading  '", path, "' ", file_index, "\n", sep = "")
+            }
+            file_index <<- file_index + 1
+
+            lines <- file_handle |> readLines()
+            file_handle |> close()
+
+            ter_line_index <- which(
+                lines |> stringr::str_detect("^TER"),
+                arr.ind = TRUE)
+
+        lines[(ter_line_index + 1) : (length(lines) - 1)] |>
+            paste0(collapse = "\n") |>
+            readr::read_delim(
+                delim = " ",
+                col_names = c("key", "value"),
+                show_col_types = FALSE) |>
+            dplyr::mutate(
+                id = path |>
+                    basename() |>
+                    stringr::str_replace_all(".pdb.gz", ""),
+                .before = 1) |>
+            dplyr::mutate(
+                pdb = lines[1:ter_line_index] |> paste0(collapse = "\n"))
+
+        })
+    models <- arrow::arrow_table(models)
+    models$pdb <- models$pdb$cast(arrow::string())
+    models |> arrow::write_parquet(output_path)
+}
+
+
+# call assemble_rosetta_models for the high_quality and low_quality datasets
+dataset_tag <- "rosetta_high_quality_models"
+assemble_rosetta_models(
+    data_path = paste0(
+        "data/microbiome_immunity_project_dataset/dataset/",
+        dataset_tag),
+    output_path = paste0("intermediate/", dataset_tag, ".parquet"))
+
+dataset_tag <- "rosetta_low_quality_models"
+assemble_rosetta_models(
+    data_path = paste0(
+        "data/microbiome_immunity_project_dataset/dataset/",
+        dataset_tag),
+    output_path = paste0("intermediate/", dataset_tag, ".parquet"))
+
+#' Assemble a DMP-Fold models dataset
+#'
+#' @param data_path character directory .pdb.gz files are located
+#' @param output_path character output .parquet path
+#'
+#' Write output_path .parquet file with columns
+#'   <id> <pdb>
+#'
+#' Note that dmpfold doesn't write out score lines like Rosetta
+assemble_dmpfold_models <- function(
+    data_path,
+    output_path) {
+
+    cat(
+        "data path: ", data_path, "\n",
+        "output path: ", output_path, "\n",
+        sep = "")
+
+    file_index <- 1
+    models <- list.files(
+        path = data_path,
+        full.names = TRUE,
+        pattern = "*.pdb.gz",
+        recursive = TRUE) |>
+        purrr::map_dfr(.f = function(path) {
+            file_handle <- path |>
+                file(open = "rb") |>
+                gzcon()
+
+            if (file_index %% 1000 == 0) {
+                cat("Reading  '", path, "' ", file_index, "\n", sep = "")
+            }
+            file_index <<- file_index + 1
+
+            lines <- file_handle |> readLines()
+            file_handle |> close()
+
+            ter_line_index <- which(
+                lines |> stringr::str_detect("^TER"),
+                arr.ind = TRUE)
+
+            data.frame(
+                id = path |> basename() |> stringr::str_replace_all(".pdb.gz", ""),
+                pdb = lines[1:ter_line_index] |> paste0(collapse = "\n"))
+        })
+    models |>
+        arrow::write_parquet(output_path)
+}
+
+# call assemble_rosetta_models for the high_quality and low_quality datasets
+dataset_tag <- "dmpfold_high_quality_models"
+assemble_dmpfold_models(
+    data_path = paste0(
+        "data/microbiome_immunity_project_dataset/dataset/",
+        dataset_tag),
+    output_path = paste0("intermediate/", dataset_tag, ".parquet"))
+
+dataset_tag <- "dmpfold_low_quality_models"
+assemble_dmpfold_models(
+    data_path = paste0(
+        "data/microbiome_immunity_project_dataset/dataset/",
+        dataset_tag),
+    output_path = paste0("intermediate/", dataset_tag, ".parquet"))
+
+
+####################################
+##                                ##
+##  Assemble Function Predictions ##
+##                                ##
+####################################
+
+
+#' Assemble DeepFRI Function Prediction dataset
+#'
+#' @param data_path character directory where *_pred_scores.json.gz files are located
+#' @param output_path character output .parquet path
+#'
+#' Write output_path .parquet file with columns
+#'   <id> <term_id> <term_name> <Y_hat>
+#'
+#' <id>: Structure identifier like `MIP_00004873`
+#' <term_ontology>: term onlogy, one of [BP, CC, EC, or MF]
+#' <term_id>: GO or EC term identifiers like `GO:0009225`
+#' <term_name> is the description of the term
+assemble_DeepFRI_function_predictions <- function(
+    data_path,
+    output_path) {
+
+    cat(
+        "data path: ", data_path, "\n",
+        "output path: ", output_path, "\n",
+        sep = "")
+
+    file_index <- 1
+
+    scores <- c("BP", "CC", "EC", "MF") |>
+        purrr::map_dfr(.f = function(ontology) {
+            cat("Reading predictions cores for ontology ", ontology, "\n", sep = "")
+            list.files(
+                path = data_path,
+                full.names = TRUE,
+                pattern = paste0("*_", ontology, "_pred_scores.json.gz"),
+                recursive = TRUE) |>
+                purrr::map_dfr(.f = function(path) {
+                    cat("Reading  '", path, "' ", file_index, "\n", sep = "")
+                    file_index <<- file_index + 1
+
+                    data <- jsonlite::fromJSON(txt = path)
+
+                    scores <- as.data.frame(data$Y_hat)
+                    names(scores) <- data$goterms
+                    scores <- scores |>
+                        dplyr::mutate(
+                            id = data$pdb_chains,
+                            .before = 1) |>
+                        tidyr::pivot_longer(
+                            cols = -"id",
+                            names_to = "term_id",
+                            values_to = "Y_hat") |>
+                        dplyr::left_join(
+                            data.frame(
+                                term_ontology = ontology,
+                                term_id = data$goterms,
+                                term_name = data$gonames),
+                            by = "term_id") |>
+                        dplyr::select(
+                            id,
+                            term_ontology,
+                            term_id,
+                            term_name,
+                            Y_hat)
+                })
+        })
+
+    scores |>
+        arrow::write_parquet(output_path)
+
+}
+
+# call assemble_rosetta_models for all the datasets
+dataset_tag <- "rosetta_high_quality_function_predictions"
+assemble_DeepFRI_function_predictions(
+    data_path = paste0(
+        "data/microbiome_immunity_project_dataset/dataset/",
+        dataset_tag),
+    output_path = paste0("intermediate/", dataset_tag, ".parquet"))
+
+dataset_tag <- "rosetta_low_quality_function_predictions"
+assemble_DeepFRI_function_predictions(
+    data_path = paste0(
+        "data/microbiome_immunity_project_dataset/dataset/",
+        dataset_tag),
+    output_path = paste0("intermediate/", dataset_tag, ".parquet"))
+
+
+dataset_tag <- "dmpfold_high_quality_function_predictions"
+assemble_DeepFRI_function_predictions(
+    data_path = paste0(
+        "data/mxoicrobiome_immunity_project_dataset/dataset/",
+        dataset_tag),
+    output_path = paste0("intermediate/", dataset_tag, ".parquet"))
+
+dataset_tag <- "dmpfold_low_quality_function_predictions"
+assemble_DeepFRI_function_predictions(
+    data_path = paste0(
+        "data/microbiome_immunity_project_dataset/dataset/",
+        dataset_tag),
+    output_path = paste0("intermediate/", dataset_tag, ".parquet"))
+
+

src/02.2_check_assembled_datasets.R

@@ -0,0 +1,64 @@
+
+
+# consistency between models and function predictions
+source("product/MPI/src/summarize_map.R")
+
+
+check_function_prediction_pivot <- function(dataset_tag, verbose = FALSE) {
+
+    if (verbose) {
+        "Checking function prediction pivot for dataset ", dataset_tag, "\n", sep = "")
+    }
+    dataset_long <- arrow::read_parquet(
+        paste0("intermediate/", dataset_tag, "_function_predictions.parquet"))
+
+    dataset_wide <- dataset_long |>
+        dplyr::select(-term_name) |>
+        tidyr::pivot_wider(
+            id_cols = id,
+            names_from = term_id,
+            values_from = Y_hat)
+
+    sum(is.na(dataset_wide))
+}
+
+check_function_prediction_pivot("rosetta_high_quality")
+check_function_prediction_pivot("rosetta_low_quality")
+check_function_prediction_pivot("dmpfold_high_quality")
+check_function_prediction_pivot("dmpfold_low_quality")
+
+
+
+check_id_consistency <- function(dataset_tag, verbose = FALSE) {
+    if (verbose) {
+        cat("Loading model ids...\n")
+    }
+    ids_model <- arrow::read_parquet(
+        paste0("intermediate/", dataset_tag, "_models.parquet"),
+        col_select = "id")
+
+    if (verbose) {
+        cat("Loading function prediction ids...\n")
+    }    
+    ids_anno <- arrow::read_parquet(
+        paste0("intermediate/", dataset_tag, "_function_predictions.parquet"),
+        col_select = "id") |>
+        dplyr::distinct(id)
+
+    problems <- dplyr::full_join(
+        ids_model |>
+        dplyr::mutate(model_id = id),
+        ids_anno |>
+        dplyr::mutate(anno_id = id),
+        by = "id") |>
+        summarize_map(
+            x_cols = model_id,
+            y_cols = anno_id,
+            verbose = verbose)
+    problems
+}
+
+check_id_consistency("rosetta_high_quality")
+check_id_consistency("rosetta_low_quality")
+check_id_consistency("dmpfold_high_quality")
+check_id_consistency("dmpfold_low_quality")

src/03.1_uplaod_data.py

@@ -0,0 +1,156 @@
+
+
+
+# install huggingface_hub from the command line:
+#
+#    pip install huggingface_hub
+#    pip install datasets
+#
+# Log into huggingface hub
+#  
+#    huggingface-cli login
+# 
+# This will ask you for an access token
+
+
+import datasets
+
+##### rosetta_high_quality_models #######
+dataset = datasets.load_dataset(
+    "parquet",
+    name = "rosetta_high_quality_models",
+    data_dir = "./intermediate",
+    data_files = {"train" : "rosetta_high_quality_models.parquet"},
+    cache_dir = "/scratch/maom_root/maom0/maom",
+    split = "train",
+    keep_in_memory = True)
+
+dataset.push_to_hub(
+    repo_id = "RosettaCommons/MIP",
+    config_name = "rosetta_high_quality_models",
+    data_dir = "rosetta_high_quality_models/data")
+
+
+
+##### rosetta_low_quality_models #######
+dataset = datasets.load_dataset(
+    "parquet",
+    name = "rosetta_low_quality_models",
+    data_dir = "./intermediate",
+    data_files = {"train" : "rosetta_low_quality_models.parquet"},
+    cache_dir = "/scratch/maom_root/maom0/maom",
+    split = "train",
+    keep_in_memory = True)
+
+dataset.push_to_hub(
+    repo_id = "RosettaCommons/MIP",
+    config_name = "rosetta_low_quality_models",
+    data_dir = "rosetta_low_quality_models/data")
+
+
+##### dmpfold_high_quality_models #######
+dataset = datasets.load_dataset(
+    "parquet",
+    name = "dmpfold_high_quality_models",
+    data_dir = "./intermediate",
+    data_files = {"train" : "dmpfold_high_quality_models.parquet"},
+    cache_dir = "/scratch/maom_root/maom0/maom",
+    split = "train",
+    keep_in_memory = True)
+
+dataset.push_to_hub(
+    repo_id = "RosettaCommons/MIP",
+    config_name = "dmpfold_high_quality_models",
+    data_dir = "dmpfold_high_quality_models/data")
+
+
+
+##### dmpfold_low_quality_models #######
+dataset = datasets.load_dataset(
+    "parquet",
+    name = "dmpfold_low_quality_models",
+    data_dir = "./intermediate",
+    data_files = {"train" : "dmpfold_low_quality_models.parquet"},
+    cache_dir = "/scratch/maom_root/maom0/maom",
+    split = "train",
+    keep_in_memory = True)
+
+dataset.push_to_hub(
+    repo_id = "RosettaCommons/MIP",
+    config_name = "dmpfold_low_quality_models",
+    data_dir = "dmpfold_low_quality_models/data")
+
+##########################
+## Function Predictions ##
+##########################
+
+#### rosetta_high_quality_function_predictions
+dataset = datasets.load_dataset(
+    "parquet",
+    name = "rosetta_high_quality_function_predictions",
+    data_dir = "./intermediate",
+    data_files = {"train" : "rosetta_high_quality_function_predictions.parquet"},
+    cache_dir = "/scratch/maom_root/maom0/maom",
+    split = "train",
+    keep_in_memory = True)
+
+dataset.push_to_hub(
+    repo_id = "RosettaCommons/MIP",
+    config_name = "rosetta_high_quality_function_predictions",
+    data_dir = "rosetta_high_quality_function_predictions/data")
+
+#### rosetta_low_quality_function_predictions
+dataset = datasets.load_dataset(
+    "parquet",
+    name = "rosetta_low_quality_function_predictions",
+    data_dir = "./intermediate",
+    data_files = {"train" : "rosetta_low_quality_function_predictions.parquet"},
+    cache_dir = "/scratch/maom_root/maom0/maom",
+    split = "train",
+    keep_in_memory = True)
+
+dataset.push_to_hub(
+    repo_id = "RosettaCommons/MIP",
+    config_name = "rosetta_low_quality_function_predictions",
+    data_dir = "rosetta_low_quality_function_predictions/data")
+
+
+
+
+#### dmpfold_high_quality_function_predictions
+dataset = datasets.load_dataset(
+    "parquet",
+    name = "dmpfold_high_quality_function_predictions",
+    data_dir = "./intermediate",
+    data_files = {"train" : "dmpfold_high_quality_function_predictions.parquet"},
+    cache_dir = "/scratch/maom_root/maom0/maom",
+    split = "train",
+    keep_in_memory = True)
+
+dataset.push_to_hub(
+    repo_id = "RosettaCommons/MIP",
+    config_name = "dmpfold_high_quality_function_predictions",
+    data_dir = "dmpfold_high_quality_function_predictions/data")
+
+#### dmpfold_low_quality_function_predictions
+dataset = datasets.load_dataset(
+    "parquet",
+    name = "dmpfold_low_quality_function_predictions",
+    data_dir = "./intermediate",
+    data_files = {"train" : "dmpfold_low_quality_function_predictions.parquet"},
+    cache_dir = "/scratch/maom_root/maom0/maom",
+    split = "train",
+    keep_in_memory = True)
+
+dataset.push_to_hub(
+    repo_id = "RosettaCommons/MIP",
+    config_name = "dmpfold_low_quality_function_predictions",
+    data_dir = "dmpfold_low_quality_function_predictions/data")
+
+
+
+
+
+
+
+

src/03.2_check_uploaded_data.py

@@ -0,0 +1,40 @@
+
+
+import datasets
+import pyarrow
+
+def test_local_hf_match(dataset_tag):
+    print(f"For dataset : '{dataset_tag}' testing if local and remote ids match ...")
+    ids_hf = datasets.load_dataset(
+        path = "RosettaCommons/MIP",
+        name = dataset_tag,
+        data_dir = dataset_tag,
+        cache_dir = "/scratch/maom_root/maom0/maom",
+        keep_in_memory = True).data['train'].select(['id']).to_pandas()
+    ids_local = pyarrow.parquet.read_table(
+        source = f"intermediate/{dataset_tag}.parquet",
+        columns = ["id"]).to_pandas()
+    assert ids_local.equals(ids_hf)
+    
+
+test_local_hf_match("rosetta_high_quality_models")
+test_local_hf_match("rosetta_low_quality_models")
+test_local_hf_match("dmpfold_high_quality_models")
+test_local_hf_match("dmpfold_low_quality_models")
+
+test_local_hf_match("rosetta_high_quality_function_predictions")
+test_local_hf_match("rosetta_low_quality_function_predictions")
+test_local_hf_match("dmpfold_high_quality_function_predictions")
+test_local_hf_match("dmpfold_low_quality_function_predictions")
+
+
+
+import pandas
+dataset_long = pyarrow.parquet.read_table(
+    "intermediate/dmpfold_low_quality_function_predictions.parquet").to_pandas()
+
+dataset_wide = pandas.pivot(
+    dataset_long[["id", "term_id", "Y_hat"]],
+    columns = "term_id",
+    index = "id",
+    values = "Y_hat")

src/summarize_map.R

@@ -0,0 +1,346 @@
+
+#'  Diagnostics for messy joins
+#'
+#'  given a data frame with two ways to group rows,
+#'  summarize and give examples of situations where the mapping is not 1-1
+#'
+#' @param x_cols tidyselect specification of a set of columns defining objects
+#' @param y_cols tidyselect specification of a set of columns defining objects
+#'
+#' data <- data.frame(
+#' 	x=c(1,2,NA,3,4,5,6,6,6,7,7),
+#' 	y=c("a",NA,"c","d","d","d","e","f","g","h","h"))
+#'
+#' data |> summarize_map(
+#'   x_cols = x),
+#'   y_cols = y))
+#' X<-[x]:
+#'   |X|: 7                          # number of groups
+#'   |is.na.X|: 1                    # number of groups with NA in atleaset 1 col
+#'   range(|x|:X): 1, 3              # size range of groups
+#' Y<-[y]:
+#'   |Y|: 7
+#'   |is.na.Y|: 1
+#'   range(|y|:Y): 1, 3
+#' [X U Y]:                          # grouping by the union of xcols and ycols
+#'   |X U Y|: 8
+#'   |is.na.XUY|: 2
+#'   range(|z|:X U Y): 1, 2
+#' [X @ Y]:
+#'   |X ~ Y|: 5
+#'   |X:X < Y|, |Y:Y < X|: 1, 1
+#'   |X:X > Y|, |Y:Y < X|: 3, 3
+#' $is.na.X
+#'    x y
+#' 1 NA c
+#'
+#' $is.na.Y
+#'   x    y
+#' 1 2 <NA>
+#'
+#' $dup.XUY
+#'   x y
+#' 1 7 h
+#' 2 7 h
+#'
+#' $dup.X
+#'   x y
+#' 1 6 e
+#' 2 6 f
+#' 3 6 g
+#'
+#' $dup.Y
+#'   y x
+#' 1 d 3
+#' 2 d 4
+#' 3 d 5
+#' @export
+summarize_map <- function(
+  data,
+  x_cols,
+  y_cols,
+  n_examples = 4,
+  verbose = FALSE) {
+
+    # convert column selections named vectors of column indices into data
+    x_cols <- tidyselect::eval_select(rlang::enquo(x_cols), data)
+    y_cols <- tidyselect::eval_select(rlang::enquo(y_cols), data)
+    xUy_cols <- union(x_cols, y_cols)
+    names(xUy_cols) <- names(data[xUy_cols])
+    
+    if(verbose) {
+        cat("The following is a report of the relationship between two different ways of identifying instances\n")
+    }
+
+    # example rows
+    problems <- list()
+
+    count_xUy <- data |>
+        dplyr::count(dplyr::across(tidyselect::all_of(xUy_cols))) |>
+        dplyr::ungroup()
+    count_x <- count_xUy |>
+        dplyr::count(dplyr::across(tidyselect::all_of(names(x_cols))), name = "size") |>
+        dplyr::ungroup()
+    count_y <- count_xUy |>
+        dplyr::count(dplyr::across(tidyselect::all_of(names(y_cols))), name = "size") |>
+        dplyr::ungroup()
+    
+    if (verbose) {
+        cat("\nProperties of X identifiers:\n")
+    }
+    cat("X<-[", paste(names(x_cols), collapse = ", "), "]:\n", sep = "")
+    cat("  |X|: ", count_x |> stats::na.omit(method = "r") |> nrow(), sep = "")
+    
+    na_count <- data |>
+        dplyr::select(tidyselect::all_of(x_cols)) |>
+        stats::complete.cases() |>
+        magrittr::not() |>
+        sum()
+    cat(
+        ifelse(
+            na_count == 0,
+            "",
+            paste0(" (", na_count, " NA)")),
+        "\n", sep = "")
+
+    size_dist <- count_x |>
+        stats::na.omit(method = "r") |>
+        dplyr::count(size) |>
+        dplyr::ungroup()
+    if (nrow(size_dist) < 12) {
+        cat("  count*size: ",
+            paste(size_dist$n, size_dist$size, sep = "*", collapse = ", "),
+            "\n", sep = "")
+	} else {
+            top <- 1:6
+            bottom <- (nrow(size_dist) - 6+1):nrow(size_dist)
+            cat("  count*size: ",
+                paste(
+                    size_dist$n[top],
+                    size_dist$size[top], sep = "*", collapse = ", "),
+                ", ... ",
+                paste(
+                    size_dist$n[bottom],
+                    size_dist$size[bottom], sep = "*", collapse = ", "),
+                "\n", sep="")
+	}
+
+    if (verbose) {
+        cat("\nProperties of the Y identifiers:\n")
+    }
+    cat("Y<-[", paste(names(y_cols), collapse = ", "), "]:\n", sep = "")
+    cat("  |Y|: ", count_y |> stats::na.omit(method = "r") |> nrow(), sep = "")
+    na_count <- data |>
+        dplyr:::select(tidyselect::all_of(y_cols)) |>
+        stats::complete.cases() |>
+        magrittr::not() |>
+        sum()
+    cat(ifelse(na_count == 0, "", paste0(" (", na_count, " NA)")), "\n", sep = "")
+    
+    size_dist <- count_y |>
+        stats::na.omit(method = "r") |>
+        dplyr::count(size) |>
+        dplyr::ungroup()
+    if (nrow(size_dist) < 12) {
+        cat("  count*size: ",
+            paste(size_dist$n, size_dist$size, sep = "*", collapse = ", "),
+            "\n", sep = "")
+    } else {
+        top <- 1:6
+        bottom <- (nrow(size_dist) - 6+1):nrow(size_dist)
+        cat("  count*size: ",
+            paste(
+                size_dist$n[top],
+                size_dist$size[top], sep = "*", collapse = ", "),
+            ", ... ",
+            paste(
+                size_dist$n[bottom],
+                size_dist$size[bottom], sep = "*", collapse = ", "),
+            "\n", sep="")
+    }
+    
+    if (verbose) {
+        cat("\nProperties of the intersection of union of the X and Y identifiers:\n")
+    }
+    cat("[X U Y]:\n")
+    cat("  |X U Y|: ", count_xUy |> stats::na.omit(method = "r") |> nrow(), sep = "")
+    na_count <- data |>
+        dplyr:::select(!!!xUy_cols) |>
+        stats::complete.cases() |>
+        magrittr::not() |>
+        sum()
+    cat(ifelse(na_count == 0, "", paste0(" (", na_count, " NA)")), "\n", sep = "")
+    
+    size_dist <- count_xUy |>
+        stats::na.omit(method = "r") |>
+        dplyr::rename(size = n) |>
+        dplyr::count(size) |>
+        dplyr::ungroup()
+    if (nrow(size_dist) < 12) {
+        cat("  count*size: ",
+            paste(size_dist$n, size_dist$size, sep = "*", collapse = ", "),
+            "\n", sep="")
+    } else {
+        top <- 1:6
+        bottom <- (nrow(size_dist) - 6+1):nrow(size_dist)
+        cat("  count*size: ",
+            paste(
+                size_dist$n[top],
+                size_dist$size[top], sep = "*", collapse = ", "),
+            ", ... ",
+            paste(
+                size_dist$n[bottom],
+                size_dist$size[bottom], sep = "*", collapse = ", "),
+            "\n", sep = "")
+    }
+    
+
+    count_xUy <- count_xUy |> stats::na.omit(method = "r")
+    
+    if (verbose) {
+        cat("Properties of the intersection of the X and Y identifiers:\n")
+    }
+    cat("[X @ Y]:\n")
+    if (verbose) {
+        cat("  Number of X and Y identifiers that are 1 to 1:\n")
+    }
+    cat("  |X ~ Y|: ",
+        count_xUy |>
+        dplyr::semi_join(
+            count_x |> dplyr::filter(size == 1),
+            by = names(x_cols)) |>
+        dplyr::semi_join(
+            count_y |> dplyr::filter(size == 1),
+            by = names(y_cols)) |>
+        nrow(),
+        "\n", sep = "")
+    
+    if (verbose) {
+        cat("  Number of X and Y identifiers where an X identifier maps to multiple Y identifiers:\n")
+    }
+    cat(
+        "  |X:X < Y|, |Y:Y < X|: ",
+        count_xUy |>
+        dplyr::semi_join(
+            count_x |> dplyr::filter(size > 1),
+            by = names(x_cols)) |>
+        nrow(),
+        ", ",
+        count_xUy |>
+        dplyr::count(
+            dplyr::across(tidyselect::all_of(names(x_cols))),
+            name = "size") |>
+        dplyr::filter(size > 1) |>
+        nrow(),
+        "\n", sep = "")
+    
+    if (verbose) {
+        cat(
+            "  Number of X and Y identifiers where a Y identifier maps to ",
+            "multiple X identifiers:\n")
+    }
+    cat(
+        "  |X:X > Y|, |Y:Y > X|: ",
+        count_xUy |>
+        dplyr::semi_join(
+            count_y |>
+            dplyr::filter(size > 1),
+            by = names(y_cols)) |>
+        nrow(),
+        ", ",
+        count_xUy |>
+        dplyr::count(
+            dplyr::across(tidyselect::all_of(names(y_cols))),
+            name = "size") |>
+        dplyr::filter(size > 1) |>
+        nrow(),
+        "\n", sep = "")
+    
+    #is.na.X
+    ex_rows <- data |>
+        dplyr:::select(tidyselect::all_of(x_cols)) |>
+        stats::complete.cases() |>
+        magrittr::not() |>
+        which()
+    if (length(ex_rows)) {
+        if (!is.null(n_examples) && (n_examples < length(ex_rows))) {
+            ex_rows <- ex_rows |> sample(n_examples, replace = FALSE)
+        }
+        problems$is.na.X <- data |>
+            dplyr::slice(ex_rows) |>
+            dplyr::arrange(dplyr::across(tidyselect::all_of(names(x_cols))))
+    }
+    
+    #is.na.Y
+    ex_rows <- data |>
+        dplyr:::select(tidyselect::all_of(y_cols)) |>
+        stats::complete.cases() |>
+        magrittr::not() |>
+        which()
+    if (length(ex_rows)) {
+        if (!is.null(n_examples) && (n_examples < length(ex_rows))) {
+            ex_rows <- ex_rows |> sample(n_examples, replace = FALSE)
+        }
+        problems$is.na.Y <- data |>
+            dplyr::slice(ex_rows) |>
+            dplyr::arrange(dplyr::across(tidyselect::all_of(names(y_cols))))
+    }
+    
+    #dup.X
+    dup.X <- count_xUy |>
+        dplyr::filter(n == 1) |>
+        dplyr::count(
+            dplyr::across(tidyselect::all_of(names(x_cols))),
+            name = "size") |>
+        dplyr::filter(size > 1) |>
+        dplyr::ungroup() |>
+        dplyr:::select(-size)
+    if (nrow(dup.X) > 1) {
+        if (!is.null(n_examples) && (n_examples < nrow(dup.X))) {
+            dup.X <- dup.X |> dplyr::sample_n(n_examples, replace = FALSE)
+        }
+        problems$dup.X <- dup.X |>
+            dplyr::left_join(data, by = names(x_cols)) |>
+            dplyr::arrange(dplyr::across(tidyselect::all_of(names(x_cols))))
+    }
+    
+    #dup.Y
+    dup.Y <- count_xUy |>
+        dplyr::filter(n == 1) |>
+        dplyr::count(
+            dplyr::across(tidyselect::all_of(names(y_cols))),
+            name = "size") |>
+        dplyr::filter(size > 1) |>
+        dplyr::ungroup() |>
+        dplyr:::select(-size)
+    if (nrow(dup.Y) > 1) {
+        if (!is.null(n_examples) && (n_examples < nrow(dup.Y))) {
+            dup.Y <- dup.Y |> dplyr::sample_n(n_examples, replace = FALSE)
+        }
+        problems$dup.Y <- dup.Y |>
+            dplyr::left_join(data, by = names(ycols)) |>
+            dplyr::arrange(dplyr::across(tidyselect::all_of(names(y_cols))))
+    }
+    
+    #dup.XUY
+    dup.XUY <- count_xUy |>
+        dplyr::filter(n > 1) |>
+        dplyr:::select(-n)
+    if (nrow(dup.XUY) > 1) {
+        if (!is.null(n_examples) && (n_examples < nrow(dup.XUY))) {
+            dup.XUY <- dup.XUY |> dplyr::sample_n(n_examples, replace = FALSE)
+        }
+        problems$dup.XUY <- dup.XUY |>
+            dplyr::left_join(data, by = names(xUy_cols)) |>
+            dplyr::arrange(dplyr::across(tidyselect::all_of(names(xUy_cols))))
+    }
+    if (verbose) {
+        cat("Returned instances where:\n")
+        cat("\tis.na.X: The X identifier is NA\n")
+        cat("\tis.na.Y: The Y identifier is NA\n")
+        cat("\tdup.X:   The X identifier is not unique\n")
+        cat("\tdup.Y:   The Y identifier is not unique\n")
+        cat("\tdup.XUY: The X and Y identifiers together are not unique\n")
+    }
+    problems
+}