Dataset Card for gbif-co-occurrence

Dataset Summary

• Motivation: To create a spatiotemporally binned co-occurrence matrix of biological taxa based on iNaturalist observation data (accessed through GBIF) suitable for machine learning tasks like predicting species distributions or analyzing community patterns.

• Source: GBIF.org (Global Biodiversity Information Facility) occurrence data, specifically from the dataset with download DOI: https://doi.org/10.15468/dl.wn7arn

• Processing: The raw observation data was processed through several steps:

  • Loading data stream from the provided URI.
  • Calculating geohash for spatial binning based on latitude and longitude.
  • Calculating week-year for temporal binning based on the event date.
  • Mapping taxonKey to a standardized hierarchical_code string based on taxonomic ranks (Kingdom, Phylum, Class, Order, Family, Genus) derived from a separate taxonomy dataset (taxonomy_dict.csv).
  • Aggregating observations by week-year and geohash bins to identify the unique hierarchical_codes present in each bin, forming the basis of the co-occurrence data.
  • The resulting co-occurrence data was saved as a dictionary of sets and then converted into a Hugging Face datasets object.
  • An intermediate column hierarchical_code_indices was created (mapping code strings to integer indices based on a vocabulary) but has since been removed from the final dataset for simplicity.

Supported Tasks and Leaderboards

• Supported Tasks: This dataset is primarily designed for machine learning tasks related to species co-occurrence analysis, species distribution modeling, and community ecology pattern analysis. Potential tasks include:
  • Predicting the presence/absence of certain taxa based on the presence of others in a geo-temporal bin.
  • Clustering spatiotemporal bins based on their taxonomic composition.
  • Analyzing changes in community composition over time and space.
• Leaderboards: Currently, there are no specific leaderboards associated with this dataset. Users are encouraged to use it for research and potentially establish benchmarks.

Dataset Structure

Data Fields

The dataset (cooccurrence_dataset) is a Hugging Face Dataset with the following columns:

• week_year (string): A string representing the week and year of the observation bin (e.g., "2023_36").
• geohash (string): A string representing the geohash of the observation bin (e.g., "dp3"). The precision of the geohash was set to 3 during processing.
• hierarchical_codes (list of strings): A list of unique hierarchical taxonomic code strings observed within that specific week_year and geohash bin.

Hierarchical Code Scheme

The hierarchical_codes are structured strings that represent the taxonomic path of an observation from Kingdom down to Genus. This scheme was developed to provide a standardized, concise, and comparable representation of taxonomic identity for each observation, derived from the original GBIF taxonomic classification.

Each code string is constructed by concatenating prefixes followed by numerical identifiers for each taxonomic rank present, in the order: K (Kingdom), P (Phylum), C (Class), O (Order), F (Family), G (Genus).

The numerical identifier following each prefix corresponds to a unique integer assigned to each distinct taxonomic name within that specific rank found across the dataset's taxonomy. This mapping from taxonomic name to numerical identifier was generated based on the unique entries in the taxonomy_dict.csv file.

For example, a code like K3P49C4O13F1641G280194 indicates:

• K3: Corresponds to the 3rd unique Kingdom name in the vocabulary for the Kingdom rank (e.g., 'Animalia').
• P49: Corresponds to the 49th unique Phylum name (e.g., 'Arthropoda').
• C4: Corresponds to the 4th unique Class name (e.g., 'Insecta').
• ...and so on for Order, Family, and Genus.

A code like K2P32C1O0F0G0 would represent an observation classified only to the Class level within that Kingdom and Phylum, with Order, Family, and Genus information missing.

To translate these full hierarchical code strings back into human-readable taxonomic rank names, please refer to the hierarchical_code_to_ranks.json file provided in the repository.

Accompanying Files

In addition to the main dataset, the repository includes the following important files:

• vocabulary.json: A JSON file containing an ordered list of all unique hierarchical taxonomic code strings found across the entire dataset. This list serves as the vocabulary for the hierarchical codes. While the hierarchical_code_indices column has been removed from the dataset, this vocabulary can still be useful if users reconstruct an index-based representation or need the complete list of unique codes.
• hierarchical_code_to_ranks.json: A JSON file containing a dictionary that maps each unique hierarchical taxonomic code string (e.g., "K3P49C4O13F1641G280194") to its corresponding taxonomic ranks (Kingdom, Phylum, Class, Order, Family, Genus). This file is essential for interpreting the hierarchical code strings found in the dataset.

Dataset Creation

Source Data

The dataset is derived from a specific GBIF occurrence data download. DOI: https://doi.org/10.15468/dl.wn7arn Creation Date: 14:16:47 14 August 2025 Records included: 52026569 records from 1 published datasets Compressed data size: 8.2 GB Download format: simple tab-separated values (TSV) Filter used:

{ "and" : [ "BasisOfRecord is Human Observation", "Country is United States of America", "DatasetKey is iNaturalist Research-grade Observations", "OccurrenceStatus is Present" ] }

Data Processing

The dataset was created by processing the raw GBIF occurrence stream. Key steps involved:

1. Loading data using the datasets library in streaming mode.
2. Calculating spatiotemporal bins (week_year and geohash) for each observation.
3. Mapping taxon IDs to standardized hierarchical code strings using a separate taxonomy source.
4. Aggregating observations into spatiotemporal bins and collecting the unique hierarchical codes present in each bin.
5. Structuring the aggregated data into a Hugging Face Dataset.

(More detailed steps or code snippets could be added here if desired)

Code Interpretation

The hierarchical_codes column contains structured strings representing the taxonomic hierarchy. To translate these codes into human-readable taxonomic names, use the hierarchical_code_to_ranks.json file.

Loading and Using the Taxonomic Ranks Mapping

You can load and use the hierarchical_code_to_ranks.json file with the huggingface_hub library and Python's json module:

try: from datasets import load_dataset

repo_id = "gbif-co-occurrence" # Replace with your actual repo ID
cooccurrence_dataset = load_dataset(repo_id, split='train') # Assuming the data is in the 'train' split
print("Dataset loaded successfully.")
print(cooccurrence_dataset)

except Exception as e: print(f"An error occurred while loading the dataset: {e}") print(f"Please ensure the repository ID '{repo_id}' is correct.")

Usage and Splitting Strategies

The cooccurrence_dataset provides the core spatiotemporal co-occurrence data, with each entry representing a unique geo-temporal bin and the list of hierarchical taxonomic codes observed within it.

For machine learning tasks, you will typically need to convert the list of hierarchical_codes into a numerical representation, such as a sparse matrix or tensor. You can use the hierarchical_code_to_ranks.json file to interpret the meaning of these codes.

Load the Dataset

You can load the dataset using the datasets library:

try: import json from huggingface_hub import hf_hub_download from scipy.sparse import csr_matrix import os

repo_id = "gbif-co-occurrence" # Replace with your actual repo ID
vocabulary_filename = "vocabulary.json"
# Download and load the vocabulary file
vocabulary_path = hf_hub_download(repo_id=repo_id, filename=vocabulary_filename, repo_type="dataset")
with open(vocabulary_path, 'r', encoding='utf-8') as f:
    vocabulary = json.load(f)

print(f"Successfully loaded vocabulary from {vocabulary_path}. Size: {len(vocabulary)}")

# Assume cooccurrence_dataset is already loaded

# Prepare data for sparse matrix construction
data = []
row_indices = []
col_indices = []

# Create a mapping from hierarchical code string to its index in the vocabulary
code_to_index = {code: index for index, code in enumerate(vocabulary)}

print("Preparing data for sparse matrix creation...")
for row_idx, record in enumerate(cooccurrence_dataset):
    codes_list = record.get('hierarchical_codes', [])
    for code in codes_list:
        # Get the index from the code_to_index mapping
        code_index = code_to_index.get(code)
        if code_index is not None: # Ensure the code is in our vocabulary
            data.append(1) # Indicate presence
            row_indices.append(row_idx)
            col_indices.append(code_index)

# Determine dimensions
num_rows = len(cooccurrence_dataset)
num_cols = len(vocabulary)

# Create the CSR matrix
cooccurrence_sparse_matrix = csr_matrix((data, (row_indices, col_indices)), shape=(num_rows, num_cols))

print("\nCSR sparse matrix created successfully.")
print(f"Shape of the sparse matrix: {cooccurrence_sparse_matrix.shape}")
# Note: This matrix can now be used as input features for ML models

except Exception as e: print(f"An error occurred while creating the sparse matrix: {e}")

Split the Dataset

from sklearn.model_selection import train_test_split

'''Assuming cooccurrence_dataset is already loaded and you have prepared your features (X) and labels (y) For example, if your features are the sparse matrix:''' X = cooccurrence_sparse_matrix

'''And your labels might be derived from the data or an external source (e.g., environmental variables) For this example, let's assume a dummy label array''' import numpy as np y = np.random.randint(0, 2, size=len(cooccurrence_dataset)) # Dummy binary labels

'''Example random split (80% train, 10% validation, 10% test) First split: train_val vs test''' X_train_val, X_test, y_train_val, y_test = train_test_split( X, y, test_size=0.1, random_state=42 )

'''Second split: train vs validation''' X_train, X_val, y_train, y_val = train_test_split( X_train_val, y_train_val, test_size=0.1 / (1 - 0.1), random_state=42 # Adjust test_size for the second split )

print(f"Original dataset size: {len(cooccurrence_dataset)}") print(f"Train set size: {X_train.shape[0]}") print(f"Validation set size: {X_val.shape[0]}") print(f"Test set size: {X_test.shape[0]}")

Additional Information

Dataset Curators

Licensing Information

Citation Information

If you use this dataset, please cite both the processed dataset (this Hugging Face dataset) and the original source data from GBIF.

To cite this dataset (the processed co-occurrence data):

https://huggingface.co/datasets/nppiech/gbif-co-occurrence, accessed (date)

To cite the original GBIF source data:

GBIF.org (14 August 2025) GBIF Occurrence Download https://doi.org/10.15468/dl.wn7arn

Contributions