Update README.md

README.md

@@ -12,7 +12,6 @@ tags:
 size_categories:
 - 10K<n<100K
 ---
-
 # Virus-Host-Genomes Dataset
 
 ## Dataset Summary
@@ -79,24 +78,19 @@ The dataset contains the following fields:
 | 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
@@ -113,9 +107,7 @@ Host labels were generated through a tier-based approach:
 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.
@@ -124,213 +116,166 @@ Some sequences were annotated using the Gemini AI system to provide additional m
 
 ## Usage Examples
 
-### Basic Loading
-
-Load the dataset using the Hugging Face Datasets library:
-
-```python
-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:
+### Data Preparation and K-mer Vectorization
 
 ```python
 import numpy as np
-from collections import Counter
+from datasets import load_dataset
 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:
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+import joblib
+from tqdm import tqdm
+
+# Load dataset
+virus_dataset = load_dataset("hiyata/Virus-Host-Genomes")
+train_dataset = virus_dataset['train']
+test_dataset = virus_dataset['test']
+
+
+# Generate k-mer dictionary once
+def generate_kmer_dict(k):
+    return {''.join(kmer): i for i, kmer in enumerate(product('ACGT', repeat=k))}
+
+# Calculate k-mer frequency
+def calculate_kmer_freq(seq, k, kmer_dict):
+    freq = np.zeros(4**k)
+    total_kmers = len(seq) - k + 1
+    for i in range(total_kmers):
+        kmer = seq[i:i+k]
+        if 'N' not in kmer and all(base in 'ACGT' for base in kmer):
+            freq[kmer_dict[kmer]] += 1
+    return freq / total_kmers if total_kmers > 0 else freq
+
+# Vectorize dataset
+def vectorize_dataset(dataset, k=4):
+    kmer_dict = generate_kmer_dict(k)
+    num_samples = len(dataset['sequence'])
+    X = np.zeros((num_samples, 4**k))
+    y = np.array(['human' if host.lower() == 'human' else 'non-human' for host in dataset['host']])
+
+    for idx, seq in enumerate(tqdm(dataset['sequence'], desc="Vectorizing sequences")):
+        X[idx] = calculate_kmer_freq(seq.upper(), k, kmer_dict)
 
-```python
-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)
+X_train, y_train = vectorize_dataset(train_dataset)
+X_test, y_test = vectorize_dataset(test_dataset)
 
-# Train a RandomForest classifier
-clf = RandomForestClassifier(n_estimators=100, random_state=42)
-clf.fit(X_train, y_train)
+# Standard Scaler
+scaler = StandardScaler()
+X_train = scaler.fit_transform(X_train)
+X_test = scaler.transform(X_test)
 
-# Evaluate the model
-y_pred = clf.predict(X_test)
-print(classification_report(y_test, y_pred))
+# Save scaler
+joblib.dump(scaler, 'standard_scaler.joblib')
 
-# Feature importance
-feature_importance = pd.DataFrame({
-    'feature': X.columns,
-    'importance': clf.feature_importances_
-}).sort_values('importance', ascending=False)
+# Label encoding
+le = LabelEncoder()
+y_train_enc = le.fit_transform(y_train)
+y_test_enc = le.transform(y_test)
 
-print("Top 10 important k-mers:")
-print(feature_importance.head(10))
+print("Vectorization complete.")
 ```
 
-### Multi-Host Classification
+### Neural Network Training for Host Classification
+
+```python
+import torch
+from torch import nn, optim
+from torch.utils.data import DataLoader, TensorDataset
+
+# Define your neural network
+class VirusClassifier(nn.Module):
+    def __init__(self, input_shape: int):
+        super(VirusClassifier, self).__init__()
+        self.network = nn.Sequential(
+            nn.Linear(input_shape, 64),
+            nn.GELU(),
+            nn.BatchNorm1d(64),
+            nn.Dropout(0.3),
+
+            nn.Linear(64, 32),
+            nn.GELU(),
+            nn.BatchNorm1d(32),
+            nn.Dropout(0.3),
+
+            nn.Linear(32, 32),
+            nn.GELU(),
+
+            nn.Linear(32, 2)
+        )
+
+    def forward(self, x):
+        return self.network(x)
+
+# Device configuration
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+# DataLoader setup
+train_loader = DataLoader(TensorDataset(
+    torch.tensor(X_train, dtype=torch.float32),
+    torch.tensor(y_train_enc, dtype=torch.long)
+), batch_size=64, shuffle=True)
+
+test_loader = DataLoader(TensorDataset(
+    torch.tensor(X_test, dtype=torch.float32),
+    torch.tensor(y_test_enc, dtype=torch.long)
+), batch_size=64, shuffle=False)
+
+# Initialize the model
+model = VirusClassifier(input_shape=X_train.shape[1]).to(device)
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.Adam(model.parameters(), lr=0.001)
+
+# Training loop
+epochs = 15
+for epoch in range(epochs):
+    model.train()
+    epoch_loss = 0
+    for X_batch, y_batch in train_loader:
+        X_batch, y_batch = X_batch.to(device), y_batch.to(device)
+        optimizer.zero_grad()
+        outputs = model(X_batch)
+        loss = criterion(outputs, y_batch)
+        loss.backward()
+        optimizer.step()
+        epoch_loss += loss.item()
+    avg_loss = epoch_loss / len(train_loader)
+    print(f"Epoch [{epoch+1}/{epochs}], Loss: {avg_loss:.4f}")
+
+# Save the trained model
+torch.save(model.state_dict(), 'virus_classifier_model.pth')
+```
 
-Train a classifier to predict specific host species using the standardized_host field:
+### Model Evaluation with Matthews Correlation Coefficient
 
 ```python
-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}")
+from sklearn.metrics import classification_report, matthews_corrcoef
+
+model.eval()
+y_preds = []
+y_true = []
+
+with torch.no_grad():
+    for X_batch, y_batch in test_loader:
+        X_batch = X_batch.to(device)
+        outputs = model(X_batch)
+        preds = torch.argmax(outputs, dim=1).cpu().numpy()
+        y_preds.extend(preds)
+        y_true.extend(y_batch.numpy())
+
+# Classification Report
+report = classification_report(y_true, y_preds, target_names=['human', 'non-human'])
+print("Classification Report:\n", report)
+
+# MCC Score
+mcc = matthews_corrcoef(y_true, y_preds)
+print(f"Matthews Correlation Coefficient (MCC): {mcc:.4f}")
 ```
 
 ## Additional Information
-
 ### Citation Information
-
 ```
 @article
   author = {},