Virus-Host-Genomes Dataset

Dataset Summary

Virus-Host-Genomes is a comprehensive collection of viral genomic sequences paired with host information, containing 58,046 viral sequences. The dataset includes metadata such as viral taxonomy (family, genus), host information, geographic data, isolation sources, and various annotations including zoonotic potential indicators. This dataset was put together to support investigations into genetic determinants of host specificity, zoonotic potential, and genome-based classification models.

Supported Tasks

• Host Prediction: Using viral sequences to predict potential hosts
• Zoonotic Potential Assessment: Identifying viruses with potential to cross between species
• Taxonomic Classification: Classifying viruses based on genomic sequences
• Sequence Analysis: Extracting sequence features like k-mer frequencies for analyses or preprocessing

Dataset Structure

Data Instances

A typical data instance contains a virus genome sequence with taxonomic classification and host information:

{
  'sequence': 'CCATTCCGGG...', # Viral genomic sequence
  'family': 'Herpesviridae',  # Viral family
  'accession': 'AY446894.2', # Reference accession number
  'host': 'human',            # Primary host
  'genus': 'Cytomegalovirus', # Viral genus
  'virus_name': 'Human betaherpesvirus 5', # Common virus name
  'strain_name': 'Merlin',    # Strain name
  'isolation_date': '1999', # Isolation date
  'location': 'United Kingdom: Cardiff', # Location
  'isolation_source': 'urine from a congenitally infected child', # Source material
  'standardized_host': 'Homo sapiens', # Standardized host name
  'host_category': 'Mammal',  # Host category
  'zoonotic': False,          # Whether virus is known to be zoonotic
  # Additional metadata fields
}

Data Fields

The dataset contains the following fields:

Field Name	Type	Description	Example
sequence	string	Genomic sequence of the virus	"CCATTCCGGG..."
family	string	Taxonomic family of the virus	"Orthoherpesviridae"
accession	string	Database accession number	"AY446894.2"
host	string	Primary host (human or non-human)	"human"
genus	string	Taxonomic genus of the virus	"Cytomegalovirus"
isolation_date	string	Date when virus was isolated	"1999"
strain_name	string	Strain or isolate identifier	"Merlin"
location	string	Geographic location of isolation	"United Kingdom: Cardiff"
virus_name	string	Common name of the virus	"Human betaherpesvirus 5"
isolation_source	string	Source material of isolation	"urine from a congenitally infected child"
lab_culture	bool	Whether isolated from lab culture	true/false
wastewater_sewage	bool	Whether isolated from wastewater	true/false
standardized_host	string	Standardized host taxonomy	"Homo sapiens"
host_category	string	Category of host organism	"Mammal"
standardized_location	string	Standardized location	"United Kingdom"
zoonotic	bool	Known to cross species barriers	true/false
processing_method	string	How sequence was processed	"NGS"
gemini_annotated	bool	Annotated with Gemini AI	true/false
is_segmented	bool	Whether virus has segmented genome	true/false
segment_label	string	Label for genome segment	"NA"

Data Splits

The dataset contains train and test splits:

Split Name	Number of Instances
train	51,935
test	6,111

Dataset Creation

Source Data

This dataset compiles virus sequences from multiple public repositories, including:

• NCBI Virus
• GenBank

Data Processing

The dataset has undergone several processing steps:

• Sequence standardization (using only unambigious IUPAC nucleotide characters)
• Host information standardization
• Geographic location normalization
• Additional annotations including zoonotic potential labeling
• Quality filtering to remove low-quality or incomplete sequences

Host labels were generated through a tier-based approach:

1. Approximately 10,000 sequences were manually labeled by experts
2. First-tier automated labeling used direct string matching against known host names
3. Second-tier labeling employed pattern recognition from a species dictionary
4. For sequences that couldn't be classified by either tier, Google Gemini was used to analyze available metadata and assign host labels

Some sequences were annotated using the Gemini AI system to provide additional metadata where information was incomplete.

Considerations for Using the Data

Limitations and Biases

• Sampling Bias: The dataset may overrepresent viruses of clinical importance and underrepresent environmental viruses.
• Temporal Distribution: More recent viruses (especially those causing outbreaks) may be overrepresented.
• Geographic Bias: Samples from regions with stronger research infrastructure may be overrepresented.
• Host Bias: Human viruses and viruses from domestic/agricultural animals may be overrepresented.
• Annotation Quality: Some metadata fields are incomplete or may contain uncertainties.

Usage Examples

Basic Loading

Load the dataset using the Hugging Face Datasets library:

from datasets import load_dataset

# Load the dataset
dataset = load_dataset("hiyata/Virus-Host-Genomes")

# Display sample
print(dataset['train'][0])

K-mer Frequency Extraction

Extract k-mer frequencies from viral sequences to use as features:

import numpy as np
from collections import Counter
from itertools import product
import pandas as pd

def extract_kmers(sequence, k=3):
    """Extract k-mer frequencies from a sequence."""
    # Handle lowercase or non-standard characters
    sequence = sequence.upper()
    # Filter out non-standard nucleotides
    sequence = ''.join([c for c in sequence if c in 'ACGT'])
    
    # Generate all possible k-mers
    all_kmers = [''.join(i) for i in product('ACGT', repeat=k)]
    
    # Count k-mers in the sequence
    kmers = []
    for i in range(len(sequence) - k + 1):
        kmer = sequence[i:i+k]
        if 'N' not in kmer:  # Skip k-mers with ambiguous nucleotides
            kmers.append(kmer)
    
    # Count occurrences of each k-mer
    kmer_counts = Counter(kmers)
    
    # Create a vector of k-mer frequencies
    kmer_vector = {kmer: kmer_counts.get(kmer, 0) / max(1, len(kmers)) for kmer in all_kmers}
    
    return kmer_vector

# Apply the function to the dataset
def process_batch(examples):
    kmer_vectors = [extract_kmers(seq) for seq in examples['sequence']]
    # Convert to DataFrame for easy handling
    df = pd.DataFrame(kmer_vectors)
    # Convert back to dictionary format
    result = {col: df[col].tolist() for col in df.columns}
    return result

# Process the dataset
kmer_features = dataset['train'].map(
    process_batch, 
    batched=True, 
    batch_size=100,
    remove_columns=['sequence']  # Remove original sequence to save memory
)

# Combine with original metadata
kmer_dataset = kmer_features.add_column('host', dataset['train']['host'])
print(kmer_dataset[0])

Human/Non-Human Host Classification

Train a classifier to predict if a virus infects humans or non-humans:

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report

# Extract features and labels
def prepare_data(dataset):
    # Process sequences to extract k-mer features
    kmer_vectors = []
    hosts = []
    
    for i in range(len(dataset)):
        if i % 1000 == 0:
            print(f"Processing sample {i}/{len(dataset)}")
        
        sequence = dataset[i]['sequence']
        host = dataset[i]['host']
        
        kmer_vector = extract_kmers(sequence, k=4)
        kmer_vectors.append(kmer_vector)
        hosts.append(host)
    
    # Convert to DataFrame
    X = pd.DataFrame(kmer_vectors)
    y = pd.Series(hosts)
    
    return X, y

# Prepare the data
X, y = prepare_data(dataset['train'].select(range(5000)))  # Use a subset for demonstration

# Split into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train a RandomForest classifier
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)

# Evaluate the model
y_pred = clf.predict(X_test)
print(classification_report(y_test, y_pred))

# Feature importance
feature_importance = pd.DataFrame({
    'feature': X.columns,
    'importance': clf.feature_importances_
}).sort_values('importance', ascending=False)

print("Top 10 important k-mers:")
print(feature_importance.head(10))

Multi-Host Classification

Train a classifier to predict specific host species using the standardized_host field:

from sklearn.preprocessing import LabelEncoder
from sklearn.multiclass import OneVsRestClassifier
from sklearn.svm import LinearSVC

# Prepare the data
def prepare_multihost_data(dataset):
    # Process sequences to extract k-mer features
    kmer_vectors = []
    hosts = []
    
    for i in range(len(dataset)):
        if i % 1000 == 0:
            print(f"Processing sample {i}/{len(dataset)}")
        
        sequence = dataset[i]['sequence']
        host = dataset[i]['standardized_host']
        
        # Skip entries with missing host information
        if host is None or host == '':
            continue
        
        kmer_vector = extract_kmers(sequence, k=5)
        kmer_vectors.append(kmer_vector)
        hosts.append(host)
    
    # Convert to DataFrame
    X = pd.DataFrame(kmer_vectors)
    
    # Encode host labels
    label_encoder = LabelEncoder()
    y = label_encoder.fit_transform(hosts)
    
    return X, y, label_encoder

# Prepare the data
X, y, label_encoder = prepare_multihost_data(dataset['train'].select(range(5000)))

# Split into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train a multi-class classifier
clf = OneVsRestClassifier(LinearSVC(random_state=42))
clf.fit(X_train, y_train)

# Evaluate the model
y_pred = clf.predict(X_test)
print(classification_report(y_test, y_pred))

# Display host labels
host_labels = label_encoder.classes_
print(f"Number of host classes: {len(host_labels)}")
print("Sample host classes:", host_labels[:10])

# Function to predict host for a new sequence
def predict_host(sequence, clf, label_encoder, k=5):
    kmer_vector = extract_kmers(sequence, k=k)
    X_new = pd.DataFrame([kmer_vector])
    
    # Make prediction
    y_pred = clf.predict(X_new)
    predicted_host = label_encoder.inverse_transform(y_pred)[0]
    
    return predicted_host

# Example prediction
example_seq = dataset['train'][0]['sequence']
predicted_host = predict_host(example_seq, clf, label_encoder)
print(f"Predicted host: {predicted_host}")

Additional Information

Citation Information

@article
  author = {},
  title = {},
  year = {},
  url = {}
}