Upload 30 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+la4sr_sp2.sif filter=lfs diff=lfs merge=lfs -text

README.txt

@@ -0,0 +1,6 @@
+to run, list your fasta files in the filelist.txt files and submit the .sbatch script, or just run run_la4sr_TI-inc-algaGPT.sh if no scheduler is available
+
+alternatively, you can run the inference script (for raw outputs from next-token generation) and the model metrics script seperately
+
+expected outputs from default run are in results-archive
+

algae-filelist.txt

@@ -0,0 +1,3 @@
+generated_prompts_algae1.txt_headed.fa
+generated_prompts_algae2.txt_headed.fa
+generated_prompts_algae3.txt_headed.fa

ckpt.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c95eb4fa7488a9f311deddda7a687d261bcc17169b76eb75dca856587b959a67
+size 1037880346

contam-filelist.txt

@@ -0,0 +1,12 @@
+generated_prompts_archa1.txt_headed.fa
+generated_prompts_archa2.txt_headed.fa
+generated_prompts_archa3.txt_headed.fa
+generated_prompts_bact1.txt_headed.fa
+generated_prompts_bact2.txt_headed.fa
+generated_prompts_bact3.txt_headed.fa
+generated_prompts_fungi1.txt_headed.fa
+generated_prompts_fungi2.txt_headed.fa
+generated_prompts_fungi3.txt_headed.fa
+generated_prompts_virus1.txt_headed.fa
+generated_prompts_virus2.txt_headed.fa
+generated_prompts_virus3.txt_headed.fa

filelist.txt

@@ -0,0 +1 @@
+chlorophyta_chloroplast_proteins.fasta

infer_TI-inc-algaGPT.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""
+la4sr_infer_fasta2tsv.py — drop‑in replacement for the older LA4SR
+inference utilities used by **run_la4sr_TI-inc.sh**
+
+Changes vs. the legacy “Sample from a trained model” script
+----------------------------------------------------------
+1. **Parses a FASTA file** and feeds the collapsed sequence to the model.
+2. **Generates up to 14 tokens** per record (defaults identical to old code).
+3. **Emits a TSV** with columns: record_id, sequence, model_output.
+4. CLI knobs match the wrapper (temperature, top‑k, etc.) plus `-o`.
+
+Python ≥3.6 compatible (removed `from __future__ import annotations`).
+"""
+
+import os, sys, argparse, pickle, random
+# ---------------------------------------------------------------------------
+# Python < 3.7 compatibility: provide a fallback for contextlib.nullcontext
+# ---------------------------------------------------------------------------
+try:
+    from contextlib import nullcontext  # Python ≥3.7
+except ImportError:                      # Python 3.6 and older
+    class _NullContext:
+        def __init__(self, result=None):
+            self.result = result
+        def __enter__(self):
+            return self.result
+        def __exit__(self, *exc):
+            return False
+    nullcontext = _NullContext
+from typing import Iterator, Tuple
+
+import torch, tiktoken
+from model import GPTConfig, GPT
+
+###############################################################################
+#                             FASTA reader                                    #
+###############################################################################
+
+def stream_fasta(path: str) -> Iterator[Tuple[str, str]]:
+    """Yield (header, sequence) tuples, collapsing wrapped lines."""
+    header, seq_chunks = None, []
+    with open(path) as fh:
+        for line in fh:
+            line = line.strip()
+            if not line:
+                continue
+            if line.startswith('>'):
+                if header is not None:
+                    yield header, ''.join(seq_chunks)
+                header = line[1:].split()[0]
+                seq_chunks = []
+            else:
+                seq_chunks.append(line)
+        if header is not None:
+            yield header, ''.join(seq_chunks)
+
+###############################################################################
+#                          argument parsing                                   #
+###############################################################################
+
+def get_cli() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="LA4SR FASTA→TSV inference script")
+    # model/runtime-----------------------------------------------------------
+    p.add_argument('--init_from', default='resume',
+                   choices=['resume','gpt2','gpt2-medium','gpt2-large'],
+                   help='Model source; "resume" = local ckpt.pt')
+    p.add_argument('--out_dir', default='out',
+                   help='Directory with ckpt.pt if --init_from resume')
+    p.add_argument('--device', default='cuda')
+    p.add_argument('--dtype', default='float16',
+                   choices=['float32','bfloat16','float16'])
+    p.add_argument('--seed', type=int, default=1337)
+    p.add_argument('--compile', action='store_true')
+    # generation knobs--------------------------------------------------------
+    p.add_argument('--max_new_tokens', type=int, default=14)
+    p.add_argument('--temperature', type=float, default=0.1)
+    p.add_argument('--top_k', type=int, default=10)
+    # I/O---------------------------------------------------------------------
+    p.add_argument('fasta_in', help='Input FASTA')
+    p.add_argument('-o','--tsv_out', help='Output TSV (default: out-algaGPT/<basename>.tsv)')
+    return p.parse_args()
+
+args = get_cli()
+
+###############################################################################
+#                 reproducibility & autocast context                          #
+###############################################################################
+
+torch.manual_seed(args.seed)
+random.seed(args.seed)
+if torch.cuda.is_available():
+    torch.cuda.manual_seed_all(args.seed)
+
+device_type = 'cuda' if 'cuda' in args.device else 'cpu'
+ptdtype_map = {'float32': torch.float32,
+               'bfloat16': torch.bfloat16,
+               'float16': torch.float16}
+ptdtype = ptdtype_map[args.dtype]
+ctx = nullcontext() if device_type == 'cpu' else torch.amp.autocast(device_type=device_type, dtype=ptdtype)
+
+###############################################################################
+#                           model loading                                     #
+###############################################################################
+
+if args.init_from == 'resume':
+    ckpt_path = os.path.join(args.out_dir, 'ckpt.pt')
+    checkpoint = torch.load(ckpt_path, map_location=args.device)
+    gptconf = GPTConfig(**checkpoint['model_args'])
+    model = GPT(gptconf)
+    # strip DDP prefixes if present
+    state_dict = {k.replace('_orig_mod.',''):v for k,v in checkpoint['model'].items()}
+    model.load_state_dict(state_dict)
+else:
+    model = GPT.from_pretrained(args.init_from, dict(dropout=0.0))
+
+model.to(args.device).eval()
+if args.compile:
+    model = torch.compile(model)
+
+###############################################################################
+#                       encoding / decoding setup                             #
+###############################################################################
+
+if args.init_from == 'resume' and 'config' in locals().get('checkpoint',{}):
+    cfg = checkpoint['config']
+    meta_path = os.path.join('data', cfg.get('dataset',''), 'meta.pkl')
+else:
+    meta_path = ''
+# ------------------------------------------------------------------
+# Fallback: meta.pkl next to ckpt.pt / in --out_dir
+# ------------------------------------------------------------------
+if (not meta_path or not os.path.exists(meta_path)) and args.out_dir:
+    alt_meta = os.path.join(args.out_dir, 'meta.pkl')
+    if os.path.exists(alt_meta):
+        meta_path = alt_meta
+
+if meta_path and os.path.exists(meta_path):
+    with open(meta_path,'rb') as f:
+        meta = pickle.load(f)
+    stoi, itos = meta['stoi'], meta['itos']
+    #encode = lambda s: [stoi.get(c, stoi['<unk>']) for c in s]
+    UNK_ID = stoi.get('<unk>', 0)   # fall back to 0 if not present
+    encode = lambda s: [stoi.get(c, UNK_ID) for c in s]
+    decode = lambda l: ''.join(itos[i] for i in l)
+
+else:
+    enc = tiktoken.get_encoding('gpt2')
+    encode = lambda s: enc.encode(s, allowed_special={""})
+    decode = lambda l: enc.decode(l)
+
+###############################################################################
+#                               output path                                   #
+###############################################################################
+
+os.makedirs('out-algaGPT', exist_ok=True)
+outfile = args.tsv_out or os.path.join('out-algaGPT', f"{os.path.splitext(os.path.basename(args.fasta_in))[0]}.tsv")
+
+###############################################################################
+#                              generation loop                                #
+###############################################################################
+
+with open(outfile,'w') as tsv, torch.no_grad(), ctx:
+    tsv.write('record_id\tsequence\tmodel_output\n')
+    for rid, seq in stream_fasta(args.fasta_in):
+        if not seq:
+            print(f"[WARN] empty sequence for {rid}; skipping", file=sys.stderr)
+            continue
+        x = torch.tensor(encode(seq), dtype=torch.long, device=args.device).unsqueeze(0)
+        try:
+            y = model.generate(x, args.max_new_tokens, temperature=args.temperature, top_k=args.top_k)
+            cont = decode(y[0].tolist())
+        except Exception as e:
+            print(f"[ERR] generation failed on {rid}: {e}", file=sys.stderr)
+            cont = ''
+        tsv.write(f"{rid}\t{seq}\t{cont}\n")
+
+print(f"\n✓ Predictions saved to {outfile}\n")
+

la4sr_sp2.sif

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5b1004d7425ffc698a13ffc537d8c25fd4073ac383d5b583d01971b4616069b7
+size 7201992704

la4sr_sp2.sif.md5

@@ -0,0 +1 @@
+0ce6720b829a4eb28d87ded1301da3ca  la4sr_sp2.sif

llm-metrics-two-files.py

@@ -0,0 +1,475 @@
+#!/usr/bin/env python3
+"""
+LLM Classification Metrics Generator for Two-File Analysis
+
+This script analyzes the LLM classification results from two separate files:
+- One containing algal sequences (true algal samples)
+- One containing contaminant sequences (true contaminant samples)
+
+It extracts the predicted tags and calculates comprehensive metrics.
+"""
+
+import re
+import sys
+import argparse
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.metrics import precision_recall_fscore_support, accuracy_score, confusion_matrix
+from sklearn.metrics import classification_report
+
+def parse_files(algal_file, contaminant_file):
+    """
+    Parse the algal and contaminant files to extract true and predicted labels
+    
+    Arguments:
+        algal_file (str): Path to the file containing algal sequences
+        contaminant_file (str): Path to the file containing contaminant sequences
+        
+    Returns:
+        tuple: Lists of true labels and predicted labels
+    """
+    true_labels = []
+    predicted_labels = []
+    sequence_ids = []
+    
+    # Process algal file (all true labels are 'algal')
+    with open(algal_file, 'r') as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            
+            # Skip header or non-data lines
+            if line.startswith('==>') or line.startswith('('): ## or not re.search(r'-|_', line):
+                continue
+                
+            # Extract sequence ID
+            seq_id_match = re.match(r'^([^\s]+)', line)
+            if seq_id_match:
+                seq_id = seq_id_match.group(1)
+            else:
+                seq_id = "unknown_id"
+            
+            # Add to tracking lists
+            true_labels.append('algal')
+            sequence_ids.append(seq_id)
+            
+            # Determine predicted label based on tags
+            if '@' in line:
+                predicted_labels.append('algal')
+            elif '!' in line:
+                predicted_labels.append('contaminant')
+            else:
+                predicted_labels.append('unknown')
+            #if re.search(r'<@+>', line):
+             #   predicted_labels.append('algal')
+            #elif re.search(r'<!+>', line):
+             #   predicted_labels.append('contaminant')
+            #else:
+             #   predicted_labels.append('unknown')
+    
+    # Process contaminant file (all true labels are 'contaminant')
+    with open(contaminant_file, 'r') as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            
+            # Skip header or non-data lines
+            if line.startswith('==>') or line.startswith('('): ## or not re.search(r'\.|_', line):
+                continue
+                
+            # Extract sequence ID
+            seq_id_match = re.match(r'^([^\s]+)', line)
+            if seq_id_match:
+                seq_id = seq_id_match.group(1)
+            else:
+                seq_id = "unknown_id"
+            
+            # Add to tracking lists
+            true_labels.append('contaminant')
+            sequence_ids.append(seq_id)
+            
+            # Determine predicted label based on tags
+           # if re.search(r'<@+>', line):
+            #    predicted_labels.append('algal')
+            #elif re.search(r'<!+>', line):
+             #   predicted_labels.append('contaminant')
+            #e#lse:
+             #   predicted_labels.append('unknown')
+            # Determine predicted label based on symbols (@ for algal, ! for contaminant)
+            if '@' in line:
+                predicted_labels.append('algal')
+            elif '!' in line:
+                predicted_labels.append('contaminant')
+            else:
+                predicted_labels.append('unknown')
+    
+    return true_labels, predicted_labels, sequence_ids
+
+def calculate_metrics(true_labels, predicted_labels):
+    """
+    Calculate comprehensive classification metrics
+    
+    Arguments:
+        true_labels (list): List of true class labels
+        predicted_labels (list): List of predicted class labels
+        
+    Returns:
+        dict: Dictionary containing all calculated metrics
+    """
+    # Convert labels for sklearn functions
+    classes = ['algal', 'contaminant']
+    label_map = {label: i for i, label in enumerate(classes)}
+    
+    # Convert to numeric form
+    true_numeric = np.array([label_map.get(label, 2) for label in true_labels])
+    pred_numeric = np.array([label_map.get(label, 2) for label in predicted_labels])
+    
+    # Filter out unknowns for main metrics
+    known_indices = [i for i, pred in enumerate(predicted_labels) if pred != 'unknown']
+    true_known = [true_labels[i] for i in known_indices]
+    pred_known = [predicted_labels[i] for i in known_indices]
+    
+    # Overall accuracy (including unknowns as wrong predictions)
+    accuracy = sum(t == p for t, p in zip(true_labels, predicted_labels)) / len(true_labels)
+    
+    if true_known and pred_known:
+        # Convert to numeric
+        true_known_numeric = np.array([label_map[label] for label in true_known])
+        pred_known_numeric = np.array([label_map[label] for label in pred_known])
+        
+        # Calculate precision, recall, and F1 (excluding unknowns)
+        precision, recall, f1, support = precision_recall_fscore_support(
+            true_known_numeric, 
+            pred_known_numeric,
+            labels=[0, 1],  # algal, contaminant
+            zero_division=0
+        )
+        
+        # Create confusion matrix
+        cm = confusion_matrix(
+            true_known_numeric, 
+            pred_known_numeric,
+            labels=[0, 1]
+        )
+        
+        # Full classification report
+        report = classification_report(
+            true_known_numeric,
+            pred_known_numeric,
+            labels=[0, 1],
+            target_names=classes,
+            output_dict=True
+        )
+    else:
+        precision = recall = f1 = support = [0, 0]
+        cm = np.zeros((2, 2))
+        report = {}
+    
+    # Count occurrences and calculate per-class metrics
+    class_metrics = {}
+    for class_name in classes:
+        class_indices = [i for i, label in enumerate(true_labels) if label == class_name]
+        total = len(class_indices)
+        
+        if total == 0:
+            class_metrics[class_name] = {
+                "total": 0,
+                "correct": 0,
+                "incorrect": 0,
+                "unknown": 0,
+                "accuracy": 0,
+                "error_rate": 0
+            }
+            continue
+            
+        correct = sum(1 for i in class_indices if predicted_labels[i] == class_name)
+        unknown = sum(1 for i in class_indices if predicted_labels[i] == "unknown")
+        incorrect = total - correct - unknown
+        
+        class_metrics[class_name] = {
+            "total": total,
+            "correct": correct,
+            "incorrect": incorrect,
+            "unknown": unknown,
+            "accuracy": correct / total if total > 0 else 0,
+            "error_rate": (incorrect + unknown) / total if total > 0 else 0
+        }
+    
+    # Compile all metrics
+    metrics = {
+        "accuracy": accuracy,
+        "class_metrics": class_metrics,
+        "confusion_matrix": cm,
+        "precision": {classes[i]: precision[i] for i in range(len(classes))},
+        "recall": {classes[i]: recall[i] for i in range(len(classes))},
+        "f1": {classes[i]: f1[i] for i in range(len(classes))},
+        "support": {classes[i]: support[i] for i in range(len(classes))},
+        "classification_report": report,
+        "macro_f1": np.mean(f1),
+        "weighted_f1": np.sum(f1 * support) / np.sum(support) if np.sum(support) > 0 else 0,
+        "total_samples": len(true_labels),
+        "total_correct": sum(t == p for t, p in zip(true_labels, predicted_labels)),
+        "total_unknown": predicted_labels.count("unknown")
+    }
+    
+    return metrics
+
+def display_results(metrics, output_file=None):
+    """
+    Display comprehensive results and optionally save to file
+    
+    Arguments:
+        metrics (dict): Dictionary containing all calculated metrics
+        output_file (str, optional): Path to save results to
+    """
+    # Start capturing output if needed
+    if output_file:
+        import io
+        output_capture = io.StringIO()
+        original_stdout = sys.stdout
+        sys.stdout = output_capture
+    
+    # Print header
+    print("\n" + "="*60)
+    print("          LLM CLASSIFICATION METRICS REPORT")
+    print("="*60)
+    
+    # Overall metrics
+    print("\n=== OVERALL METRICS ===")
+    print(f"Total samples: {metrics['total_samples']}")
+    print(f"Correctly classified: {metrics['total_correct']} ({metrics['total_correct']/metrics['total_samples']*100:.2f}%)")
+    print(f"Unknown predictions: {metrics['total_unknown']} ({metrics['total_unknown']/metrics['total_samples']*100:.2f}%)")
+    print(f"Overall accuracy: {metrics['accuracy']:.4f}")
+    print(f"Macro F1: {metrics['macro_f1']:.4f}")
+    print(f"Weighted F1: {metrics['weighted_f1']:.4f}")
+    
+    # Confusion matrix
+    cm = metrics["confusion_matrix"]
+    class_labels = ["Algal", "Bacterial"]
+    
+    print("\n=== CONFUSION MATRIX ===")
+    print(f"{'':15} | {'Predicted Algal':15} | {'Predicted Bacterial':20}")
+    print("-" * 55)
+    for i, label in enumerate(class_labels):
+        print(f"{label:15} | {int(cm[i][0]):15} | {int(cm[i][1]):20}")
+    
+    # Per-class metrics
+    print("\n=== PER-CLASS METRICS ===")
+    print(f"{'Class':10} | {'Precision':10} | {'Recall':10} | {'F1 Score':10} | {'Support':10}")
+    print("-" * 60)
+    for class_name in ['algal', 'contaminant']:
+        precision = metrics['precision'][class_name]
+        recall = metrics['recall'][class_name]
+        f1 = metrics['f1'][class_name]
+        support = metrics['support'][class_name]
+        print(f"{class_name.capitalize():10} | {precision:.4f}     | {recall:.4f}     | {f1:.4f}     | {int(support):10}")
+    
+    # Detailed class counts
+    print("\n=== DETAILED CLASS COUNTS ===")
+    for class_name, class_data in metrics["class_metrics"].items():
+        print(f"{class_name.capitalize()} class:")
+        print(f"  Total samples: {class_data['total']}")
+        if class_data['total'] > 0:
+            print(f"  Correctly classified: {class_data['correct']} ({class_data['correct']/class_data['total']*100:.2f}%)")
+            print(f"  Incorrectly classified: {class_data['incorrect']} ({class_data['incorrect']/class_data['total']*100:.2f}%)")
+            print(f"  Unknown: {class_data['unknown']} ({class_data['unknown']/class_data['total']*100:.2f}%)")
+        print()
+    
+    # If saving to file
+    if output_file:
+        # Restore stdout
+        sys.stdout = original_stdout
+        
+        # Write to file
+        with open(output_file, 'w') as f:
+            f.write(output_capture.getvalue())
+        
+        print(f"Results saved to {output_file}")
+
+def generate_visualizations(metrics, output_prefix=None):
+    """
+    Generate visualizations of the metrics
+    
+    Arguments:
+        metrics (dict): Dictionary containing all calculated metrics
+        output_prefix (str, optional): Prefix for output image files
+    """
+    # Create confusion matrix heatmap
+    plt.figure(figsize=(8, 6))
+    cm = metrics["confusion_matrix"]
+    plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)
+    plt.title('Confusion Matrix')
+    plt.colorbar()
+    
+    classes = ["Algal", "Bacterial"]
+    tick_marks = np.arange(len(classes))
+    plt.xticks(tick_marks, classes, rotation=45)
+    plt.yticks(tick_marks, classes)
+    
+    # Add text annotations
+    thresh = cm.max() / 2.0
+    for i in range(cm.shape[0]):
+        for j in range(cm.shape[1]):
+            plt.text(j, i, format(int(cm[i, j]), 'd'),
+                     horizontalalignment="center",
+                     color="white" if cm[i, j] > thresh else "black")
+    
+    plt.ylabel('True label')
+    plt.xlabel('Predicted label')
+    plt.tight_layout()
+    
+    if output_prefix:
+        plt.savefig(f"{output_prefix}_confusion_matrix.png", dpi=300, bbox_inches='tight')
+    else:
+        plt.show()
+    
+    # Create per-class metrics bar chart
+    plt.figure(figsize=(10, 6))
+    
+    metrics_names = ['Precision', 'Recall', 'F1-Score']
+    x = np.arange(len(metrics_names))
+    width = 0.35
+    
+    algal_values = [metrics['precision']['algal'], metrics['recall']['algal'], metrics['f1']['algal']]
+    contaminant_values = [metrics['precision']['contaminant'], metrics['recall']['contaminant'], metrics['f1']['contaminant']]
+    
+    plt.bar(x - width/2, algal_values, width, label='Algal')
+    plt.bar(x + width/2, contaminant_values, width, label='Bacterial')
+    
+    plt.ylabel('Score')
+    plt.title('Performance Metrics by Class')
+    plt.xticks(x, metrics_names)
+    plt.ylim(0, 1.1)
+    plt.legend()
+    plt.grid(axis='y', linestyle='--', alpha=0.7)
+    
+    if output_prefix:
+        plt.savefig(f"{output_prefix}_metrics_by_class.png", dpi=300, bbox_inches='tight')
+    else:
+        plt.show()
+    
+    # Create class distribution pie charts
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
+    
+    # Algal class distribution
+    algal_data = metrics['class_metrics']['algal']
+    algal_labels = ['Correct', 'Incorrect', 'Unknown']
+    algal_values = [algal_data['correct'], algal_data['incorrect'], algal_data['unknown']]
+    ax1.pie(algal_values, labels=algal_labels, autopct='%1.1f%%', startangle=90)
+    ax1.set_title('Algal Class Predictions')
+    
+    # Bacterial class distribution
+    contaminant_data = metrics['class_metrics']['contaminant']
+    contaminant_labels = ['Correct', 'Incorrect', 'Unknown']
+    contaminant_values = [contaminant_data['correct'], contaminant_data['incorrect'], contaminant_data['unknown']]
+    ax2.pie(contaminant_values, labels=contaminant_labels, autopct='%1.1f%%', startangle=90)
+    ax2.set_title('Bacterial Class Predictions')
+    
+    plt.tight_layout()
+    
+    if output_prefix:
+        plt.savefig(f"{output_prefix}_class_distribution.png", dpi=300, bbox_inches='tight')
+    else:
+        plt.show()
+
+def create_misclassified_report(true_labels, predicted_labels, sequence_ids, output_file=None):
+    """
+    Create a report of misclassified sequences
+    
+    Arguments:
+        true_labels (list): List of true class labels
+        predicted_labels (list): List of predicted class labels
+        sequence_ids (list): List of sequence IDs
+        output_file (str, optional): Path to save the report to
+    """
+    misclassified = []
+    for i, (true, pred, seq_id) in enumerate(zip(true_labels, predicted_labels, sequence_ids)):
+        if true != pred:
+            misclassified.append({
+                'id': seq_id,
+                'true': true,
+                'predicted': pred
+            })
+    
+    # Start capturing output
+    if output_file:
+        import io
+        output_capture = io.StringIO()
+        original_stdout = sys.stdout
+        sys.stdout = output_capture
+    
+    # Print header
+    print("\n" + "="*60)
+    print("          MISCLASSIFIED SEQUENCES REPORT")
+    print("="*60)
+    print(f"\nTotal misclassified: {len(misclassified)} out of {len(true_labels)} ({len(misclassified)/len(true_labels)*100:.2f}%)\n")
+    
+    # Print algal sequences misclassified as contaminant
+    print("\n--- ALGAL SEQUENCES MISCLASSIFIED AS BACTERIAL ---")
+    algal_as_contaminant = [m for m in misclassified if m['true'] == 'algal' and m['predicted'] == 'contaminant']
+    for item in algal_as_contaminant:
+        print(f"ID: {item['id']}")
+    print(f"Total: {len(algal_as_contaminant)}")
+    
+    # Print contaminant sequences misclassified as algal
+    print("\n--- BACTERIAL SEQUENCES MISCLASSIFIED AS ALGAL ---")
+    contaminant_as_algal = [m for m in misclassified if m['true'] == 'contaminant' and m['predicted'] == 'algal']
+    for item in contaminant_as_algal:
+        print(f"ID: {item['id']}")
+    print(f"Total: {len(contaminant_as_algal)}")
+    
+    # Print unknown classifications
+    print("\n--- SEQUENCES WITH UNKNOWN CLASSIFICATION ---")
+    unknown = [m for m in misclassified if m['predicted'] == 'unknown']
+    for item in unknown:
+        print(f"ID: {item['id']} (True: {item['true']})")
+    print(f"Total: {len(unknown)}")
+    
+    # If saving to file
+    if output_file:
+        # Restore stdout
+        sys.stdout = original_stdout
+        
+        # Write to file
+        with open(output_file, 'w') as f:
+            f.write(output_capture.getvalue())
+        
+        print(f"Misclassified report saved to {output_file}")
+
+def main():
+    """Main function to run the script"""
+    parser = argparse.ArgumentParser(description='LLM Classification Metrics Generator for Two-File Analysis')
+    parser.add_argument('algal_file', help='Path to the file containing algal sequences')
+    parser.add_argument('contaminant_file', help='Path to the file containing contaminant sequences')
+    parser.add_argument('-o', '--output', help='Path to save the metrics report')
+    parser.add_argument('-m', '--misclassified', help='Path to save the misclassified sequences report')
+    parser.add_argument('-v', '--visualize', action='store_true', help='Generate visualizations')
+    parser.add_argument('-p', '--prefix', default='llm_metrics', help='Prefix for output files')
+    
+    args = parser.parse_args()
+    
+    # Parse files and calculate metrics
+    true_labels, predicted_labels, sequence_ids = parse_files(args.algal_file, args.contaminant_file)
+    metrics = calculate_metrics(true_labels, predicted_labels)
+    
+    # Display results
+    output_file = f"{args.prefix}_report.txt" if args.output else None
+    display_results(metrics, output_file)
+    
+    # Generate visualizations if requested
+    if args.visualize:
+        generate_visualizations(metrics, args.prefix)
+    
+    # Create misclassified report if requested
+    if args.misclassified:
+        misclassified_file = f"{args.prefix}_misclassified.txt" if args.misclassified is True else args.misclassified
+        create_misclassified_report(true_labels, predicted_labels, sequence_ids, misclassified_file)
+    
+    # Return number of misclassifications (for automated testing)
+    misclassifications = sum(t != p for t, p in zip(true_labels, predicted_labels))
+    return misclassifications
+
+if __name__ == "__main__":
+    sys.exit(main())

meta.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75049dcc1458196491b007a46f4aa1acef9ca3c27df282f226af572877203752
+size 14858

model.py

@@ -0,0 +1,330 @@
+"""
+Full definition of a GPT Language Model, all of it in this single file.
+References:
+1) the official GPT-2 TensorFlow implementation released by OpenAI:
+https://github.com/openai/gpt-2/blob/master/src/model.py
+2) huggingface/transformers PyTorch implementation:
+https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt2/modeling_gpt2.py
+"""
+
+import math
+import inspect
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+from torch.nn import functional as F
+
+class LayerNorm(nn.Module):
+    """ LayerNorm but with an optional bias. PyTorch doesn't support simply bias=False """
+
+    def __init__(self, ndim, bias):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(ndim))
+        self.bias = nn.Parameter(torch.zeros(ndim)) if bias else None
+
+    def forward(self, input):
+        return F.layer_norm(input, self.weight.shape, self.weight, self.bias, 1e-5)
+
+class CausalSelfAttention(nn.Module):
+
+    def __init__(self, config):
+        super().__init__()
+        assert config.n_embd % config.n_head == 0
+        # key, query, value projections for all heads, but in a batch
+        self.c_attn = nn.Linear(config.n_embd, 3 * config.n_embd, bias=config.bias)
+        # output projection
+        self.c_proj = nn.Linear(config.n_embd, config.n_embd, bias=config.bias)
+        # regularization
+        self.attn_dropout = nn.Dropout(config.dropout)
+        self.resid_dropout = nn.Dropout(config.dropout)
+        self.n_head = config.n_head
+        self.n_embd = config.n_embd
+        self.dropout = config.dropout
+        # flash attention make GPU go brrrrr but support is only in PyTorch >= 2.0
+        self.flash = hasattr(torch.nn.functional, 'scaled_dot_product_attention')
+        if not self.flash:
+            print("WARNING: using slow attention. Flash Attention requires PyTorch >= 2.0")
+            # causal mask to ensure that attention is only applied to the left in the input sequence
+            self.register_buffer("bias", torch.tril(torch.ones(config.block_size, config.block_size))
+                                        .view(1, 1, config.block_size, config.block_size))
+
+    def forward(self, x):
+        B, T, C = x.size() # batch size, sequence length, embedding dimensionality (n_embd)
+
+        # calculate query, key, values for all heads in batch and move head forward to be the batch dim
+        q, k, v  = self.c_attn(x).split(self.n_embd, dim=2)
+        k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
+        q = q.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
+        v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
+
+        # causal self-attention; Self-attend: (B, nh, T, hs) x (B, nh, hs, T) -> (B, nh, T, T)
+        if self.flash:
+            # efficient attention using Flash Attention CUDA kernels
+            y = torch.nn.functional.scaled_dot_product_attention(q, k, v, attn_mask=None, dropout_p=self.dropout if self.training else 0, is_causal=True)
+        else:
+            # manual implementation of attention
+            att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1)))
+            att = att.masked_fill(self.bias[:,:,:T,:T] == 0, float('-inf'))
+            att = F.softmax(att, dim=-1)
+            att = self.attn_dropout(att)
+            y = att @ v # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs)
+        y = y.transpose(1, 2).contiguous().view(B, T, C) # re-assemble all head outputs side by side
+
+        # output projection
+        y = self.resid_dropout(self.c_proj(y))
+        return y
+
+class MLP(nn.Module):
+
+    def __init__(self, config):
+        super().__init__()
+        self.c_fc    = nn.Linear(config.n_embd, 4 * config.n_embd, bias=config.bias)
+        self.gelu    = nn.GELU()
+        self.c_proj  = nn.Linear(4 * config.n_embd, config.n_embd, bias=config.bias)
+        self.dropout = nn.Dropout(config.dropout)
+
+    def forward(self, x):
+        x = self.c_fc(x)
+        x = self.gelu(x)
+        x = self.c_proj(x)
+        x = self.dropout(x)
+        return x
+
+class Block(nn.Module):
+
+    def __init__(self, config):
+        super().__init__()
+        self.ln_1 = LayerNorm(config.n_embd, bias=config.bias)
+        self.attn = CausalSelfAttention(config)
+        self.ln_2 = LayerNorm(config.n_embd, bias=config.bias)
+        self.mlp = MLP(config)
+
+    def forward(self, x):
+        x = x + self.attn(self.ln_1(x))
+        x = x + self.mlp(self.ln_2(x))
+        return x
+
+@dataclass
+class GPTConfig:
+    block_size: int = 1024
+    vocab_size: int = 50304 # GPT-2 vocab_size of 50257, padded up to nearest multiple of 64 for efficiency
+    n_layer: int = 12
+    n_head: int = 12
+    n_embd: int = 768
+    dropout: float = 0.0
+    bias: bool = True # True: bias in Linears and LayerNorms, like GPT-2. False: a bit better and faster
+
+class GPT(nn.Module):
+
+    def __init__(self, config):
+        super().__init__()
+        assert config.vocab_size is not None
+        assert config.block_size is not None
+        self.config = config
+
+        self.transformer = nn.ModuleDict(dict(
+            wte = nn.Embedding(config.vocab_size, config.n_embd),
+            wpe = nn.Embedding(config.block_size, config.n_embd),
+            drop = nn.Dropout(config.dropout),
+            h = nn.ModuleList([Block(config) for _ in range(config.n_layer)]),
+            ln_f = LayerNorm(config.n_embd, bias=config.bias),
+        ))
+        self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
+        # with weight tying when using torch.compile() some warnings get generated:
+        # "UserWarning: functional_call was passed multiple values for tied weights.
+        # This behavior is deprecated and will be an error in future versions"
+        # not 100% sure what this is, so far seems to be harmless. TODO investigate
+        self.transformer.wte.weight = self.lm_head.weight # https://paperswithcode.com/method/weight-tying
+
+        # init all weights
+        self.apply(self._init_weights)
+        # apply special scaled init to the residual projections, per GPT-2 paper
+        for pn, p in self.named_parameters():
+            if pn.endswith('c_proj.weight'):
+                torch.nn.init.normal_(p, mean=0.0, std=0.02/math.sqrt(2 * config.n_layer))
+
+        # report number of parameters
+        print("number of parameters: %.2fM" % (self.get_num_params()/1e6,))
+
+    def get_num_params(self, non_embedding=True):
+        """
+        Return the number of parameters in the model.
+        For non-embedding count (default), the position embeddings get subtracted.
+        The token embeddings would too, except due to the parameter sharing these
+        params are actually used as weights in the final layer, so we include them.
+        """
+        n_params = sum(p.numel() for p in self.parameters())
+        if non_embedding:
+            n_params -= self.transformer.wpe.weight.numel()
+        return n_params
+
+    def _init_weights(self, module):
+        if isinstance(module, nn.Linear):
+            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
+            if module.bias is not None:
+                torch.nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Embedding):
+            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
+
+    def forward(self, idx, targets=None):
+        device = idx.device
+        b, t = idx.size()
+        assert t <= self.config.block_size, f"Cannot forward sequence of length {t}, block size is only {self.config.block_size}"
+        pos = torch.arange(0, t, dtype=torch.long, device=device) # shape (t)
+
+        # forward the GPT model itself
+        tok_emb = self.transformer.wte(idx) # token embeddings of shape (b, t, n_embd)
+        pos_emb = self.transformer.wpe(pos) # position embeddings of shape (t, n_embd)
+        x = self.transformer.drop(tok_emb + pos_emb)
+        for block in self.transformer.h:
+            x = block(x)
+        x = self.transformer.ln_f(x)
+
+        if targets is not None:
+            # if we are given some desired targets also calculate the loss
+            logits = self.lm_head(x)
+            loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1), ignore_index=-1)
+        else:
+            # inference-time mini-optimization: only forward the lm_head on the very last position
+            logits = self.lm_head(x[:, [-1], :]) # note: using list [-1] to preserve the time dim
+            loss = None
+
+        return logits, loss
+
+    def crop_block_size(self, block_size):
+        # model surgery to decrease the block size if necessary
+        # e.g. we may load the GPT2 pretrained model checkpoint (block size 1024)
+        # but want to use a smaller block size for some smaller, simpler model
+        assert block_size <= self.config.block_size
+        self.config.block_size = block_size
+        self.transformer.wpe.weight = nn.Parameter(self.transformer.wpe.weight[:block_size])
+        for block in self.transformer.h:
+            if hasattr(block.attn, 'bias'):
+                block.attn.bias = block.attn.bias[:,:,:block_size,:block_size]
+
+    @classmethod
+    def from_pretrained(cls, model_type, override_args=None):
+        assert model_type in {'gpt2', 'gpt2-medium', 'gpt2-large', 'gpt2-xl'}
+        override_args = override_args or {} # default to empty dict
+        # only dropout can be overridden see more notes below
+        assert all(k == 'dropout' for k in override_args)
+        from transformers import GPT2LMHeadModel
+        print("loading weights from pretrained gpt: %s" % model_type)
+
+        # n_layer, n_head and n_embd are determined from model_type
+        config_args = {
+            'gpt2':         dict(n_layer=12, n_head=12, n_embd=768),  # 124M params
+            'gpt2-medium':  dict(n_layer=24, n_head=16, n_embd=1024), # 350M params
+            'gpt2-large':   dict(n_layer=36, n_head=20, n_embd=1280), # 774M params
+            'gpt2-xl':      dict(n_layer=48, n_head=25, n_embd=1600), # 1558M params
+        }[model_type]
+        print("forcing vocab_size=50257, block_size=1024, bias=True")
+        config_args['vocab_size'] = 50257 # always 50257 for GPT model checkpoints
+        config_args['block_size'] = 1024 # always 1024 for GPT model checkpoints
+        config_args['bias'] = True # always True for GPT model checkpoints
+        # we can override the dropout rate, if desired
+        if 'dropout' in override_args:
+            print(f"overriding dropout rate to {override_args['dropout']}")
+            config_args['dropout'] = override_args['dropout']
+        # create a from-scratch initialized minGPT model
+        config = GPTConfig(**config_args)
+        model = GPT(config)
+        sd = model.state_dict()
+        sd_keys = sd.keys()
+        sd_keys = [k for k in sd_keys if not k.endswith('.attn.bias')] # discard this mask / buffer, not a param
+
+        # init a huggingface/transformers model
+        model_hf = GPT2LMHeadModel.from_pretrained(model_type)
+        sd_hf = model_hf.state_dict()
+
+        # copy while ensuring all of the parameters are aligned and match in names and shapes
+        sd_keys_hf = sd_hf.keys()
+        sd_keys_hf = [k for k in sd_keys_hf if not k.endswith('.attn.masked_bias')] # ignore these, just a buffer
+        sd_keys_hf = [k for k in sd_keys_hf if not k.endswith('.attn.bias')] # same, just the mask (buffer)
+        transposed = ['attn.c_attn.weight', 'attn.c_proj.weight', 'mlp.c_fc.weight', 'mlp.c_proj.weight']
+        # basically the openai checkpoints use a "Conv1D" module, but we only want to use a vanilla Linear
+        # this means that we have to transpose these weights when we import them
+        assert len(sd_keys_hf) == len(sd_keys), f"mismatched keys: {len(sd_keys_hf)} != {len(sd_keys)}"
+        for k in sd_keys_hf:
+            if any(k.endswith(w) for w in transposed):
+                # special treatment for the Conv1D weights we need to transpose
+                assert sd_hf[k].shape[::-1] == sd[k].shape
+                with torch.no_grad():
+                    sd[k].copy_(sd_hf[k].t())
+            else:
+                # vanilla copy over the other parameters
+                assert sd_hf[k].shape == sd[k].shape
+                with torch.no_grad():
+                    sd[k].copy_(sd_hf[k])
+
+        return model
+
+    def configure_optimizers(self, weight_decay, learning_rate, betas, device_type):
+        # start with all of the candidate parameters
+        param_dict = {pn: p for pn, p in self.named_parameters()}
+        # filter out those that do not require grad
+        param_dict = {pn: p for pn, p in param_dict.items() if p.requires_grad}
+        # create optim groups. Any parameters that is 2D will be weight decayed, otherwise no.
+        # i.e. all weight tensors in matmuls + embeddings decay, all biases and layernorms don't.
+        decay_params = [p for n, p in param_dict.items() if p.dim() >= 2]
+        nodecay_params = [p for n, p in param_dict.items() if p.dim() < 2]
+        optim_groups = [
+            {'params': decay_params, 'weight_decay': weight_decay},
+            {'params': nodecay_params, 'weight_decay': 0.0}
+        ]
+        num_decay_params = sum(p.numel() for p in decay_params)
+        num_nodecay_params = sum(p.numel() for p in nodecay_params)
+        print(f"num decayed parameter tensors: {len(decay_params)}, with {num_decay_params:,} parameters")
+        print(f"num non-decayed parameter tensors: {len(nodecay_params)}, with {num_nodecay_params:,} parameters")
+        # Create AdamW optimizer and use the fused version if it is available
+        fused_available = 'fused' in inspect.signature(torch.optim.AdamW).parameters
+        use_fused = fused_available and device_type == 'cuda'
+        extra_args = dict(fused=True) if use_fused else dict()
+        optimizer = torch.optim.AdamW(optim_groups, lr=learning_rate, betas=betas, **extra_args)
+        print(f"using fused AdamW: {use_fused}")
+
+        return optimizer
+
+    def estimate_mfu(self, fwdbwd_per_iter, dt):
+        """ estimate model flops utilization (MFU) in units of A100 bfloat16 peak FLOPS """
+        # first estimate the number of flops we do per iteration.
+        # see PaLM paper Appendix B as ref: https://arxiv.org/abs/2204.02311
+        N = self.get_num_params()
+        cfg = self.config
+        L, H, Q, T = cfg.n_layer, cfg.n_head, cfg.n_embd//cfg.n_head, cfg.block_size
+        flops_per_token = 6*N + 12*L*H*Q*T
+        flops_per_fwdbwd = flops_per_token * T
+        flops_per_iter = flops_per_fwdbwd * fwdbwd_per_iter
+        # express our flops throughput as ratio of A100 bfloat16 peak flops
+        flops_achieved = flops_per_iter * (1.0/dt) # per second
+        flops_promised = 312e12 # A100 GPU bfloat16 peak flops is 312 TFLOPS
+        mfu = flops_achieved / flops_promised
+        return mfu
+
+    @torch.no_grad()
+    def generate(self, idx, max_new_tokens, temperature=1.0, top_k=None):
+        """
+        Take a conditioning sequence of indices idx (LongTensor of shape (b,t)) and complete
+        the sequence max_new_tokens times, feeding the predictions back into the model each time.
+        Most likely you'll want to make sure to be in model.eval() mode of operation for this.
+        """
+        for _ in range(max_new_tokens):
+            # if the sequence context is growing too long we must crop it at block_size
+            idx_cond = idx if idx.size(1) <= self.config.block_size else idx[:, -self.config.block_size:]
+            # forward the model to get the logits for the index in the sequence
+            logits, _ = self(idx_cond)
+            # pluck the logits at the final step and scale by desired temperature
+            logits = logits[:, -1, :] / temperature
+            # optionally crop the logits to only the top k options
+            if top_k is not None:
+                v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
+                logits[logits < v[:, [-1]]] = -float('Inf')
+            # apply softmax to convert logits to (normalized) probabilities
+            probs = F.softmax(logits, dim=-1)
+            # sample from the distribution
+            idx_next = torch.multinomial(probs, num_samples=1)
+            # append sampled index to the running sequence and continue
+            idx = torch.cat((idx, idx_next), dim=1)
+
+        return idx

run_la4sr_TI-inc-algaGPT.sh

@@ -0,0 +1,144 @@
+#!/usr/bin/env bash
+set -euo pipefail
+###############################################################################
+# run_la4sr_TI-inc.sh — LA4SR pipeline: model inference (FASTA→TSV) + metrics
+###############################################################################
+
+# ---------------------- Configuration ----------------------
+SCRIPT_DIR="$(pwd)"
+INFER_SCRIPT="$SCRIPT_DIR/infer_TI-inc-algaGPT.py"   # <— new script
+METRICS_SCRIPT="$SCRIPT_DIR/llm-metrics-two-files.py"
+SIF="$SCRIPT_DIR/la4sr_sp2.sif"
+
+# cache for HF tokenizers & models
+tcache="$SCRIPT_DIR/cache"
+mkdir -p "$tcache"
+
+# ---------------------- Usage ----------------------
+if [[ $# -ne 3 ]]; then
+  cat <<EOF
+Usage: $(basename "$0") <model_name|resume> <algal_fasta> <bacterial_fasta>
+
+If you pass the literal word   resume   the script loads ckpt.pt + meta.pkl
+from the current directory. Otherwise the value is forwarded to --init_from
+(e.g. GreenGenomicsLab/LA4SR-gpt-neo125-ALMGA-FL).
+
+EOF
+  exit 1
+fi
+
+MODEL_NAME="$1"          # "resume"  OR  HF repo / local path
+algal_fasta="$2"
+bact_fasta="$3"
+
+prefix="$(basename "${algal_fasta%.*}")_vs_$(basename "${bact_fasta%.*}")"
+mkdir -p results
+alg_out="results/${prefix}_algal.tsv"
+bac_out="results/${prefix}_bacterial.tsv"
+alg_out_tagged="results/${prefix}_algal_tagged.tsv"
+bac_out_tagged="results/${prefix}_bacterial_tagged.tsv"
+report="results/${prefix}_report.txt"
+miscl="results/${prefix}_misclassified.txt"
+
+# ---------------------- Inference ----------------------
+
+run_infer () {
+  local fasta=$1 out=$2
+  echo -e "\n→ Inferring $(basename "$fasta")..."
+
+  # Build common args
+  PY_ARGS=( --init_from "$MODEL_NAME" )
+  [[ "$MODEL_NAME" == "resume" ]] && PY_ARGS+=( --out_dir /workdir )
+
+  singularity exec --nv \
+    -B "$fasta:/input.fasta" \
+    -B "$(pwd):/workdir" \
+    -B "$tcache:$tcache" \
+    --env TRANSFORMERS_CACHE="$tcache" \
+    "$SIF" \
+    bash -c 'cd /workdir && \
+      python3 infer_TI-inc-algaGPT.py '"${PY_ARGS[*]}"' /input.fasta -o "'"$out"'"'
+}
+
+#run_infer () {
+  #local fasta=$1 out=$2
+  #echo -e "\n→ Inferring $(basename "$fasta")..."
+
+  #PY_ARGS=( --init_from "$MODEL_NAME" )
+  #[[ "$MODEL_NAME" == "resume" ]] && PY_ARGS+=( --out_dir /workdir )
+
+ # singularity exec --nv \
+   # -B "$fasta:/input.fasta" \
+   # -B "$(pwd):/workdir" \          # <— whole project goes in
+   # -B "$tcache:$tcache" \
+   # --env TRANSFORMERS_CACHE="$tcache" \
+   # "$SIF" \
+   # bash -c "cd /workdir && \
+  #           python3 "$INFER_SCRIPT" \
+ #              \"${PY_ARGS[@]}\" /input.fasta -o \"$out\""
+#}
+
+#run_infer () {
+ # local fasta=$1 out=$2
+  #echo -e "\n→ Inferring $(basename "$fasta")..."
+
+  # build python arg list: --init_from ... [--out_dir PWD]
+  #PY_ARGS=( --init_from "$MODEL_NAME" )
+  #[[ "$MODEL_NAME" == "resume" ]] && PY_ARGS+=( --out_dir "$SCRIPT_DIR" )
+
+  #if [[ -f "$SIF" ]]; then
+   # singularity exec --nv \
+    #  -B "$fasta:/input.fasta" \
+     # -B "$INFER_SCRIPT:/infer.py" \
+      #-B "$(pwd):/workdir" \
+      #-B "$tcache:$tcache" \
+      #--env TRANSFORMERS_CACHE="$tcache" \
+      #"$SIF" \
+      #python3 /infer.py "${PY_ARGS[@]}" /input.fasta \
+       # -o "/workdir/$out"
+  #else
+   # TRANSFORMERS_CACHE="$tcache" \
+    #python3 "$INFER_SCRIPT" "${PY_ARGS[@]}" "$fasta" \
+     # -o "$out"
+  #fi
+
+  #echo "   ✔ Wrote $out"
+#}
+
+run_infer "$algal_fasta" "$alg_out"
+run_infer "$bact_fasta"  "$bac_out"
+
+# ---------------------- Post-process Tags ----------------------
+convert_tags () {
+  local infile=$1 outfile=$2
+  echo -e "\n→ Converting 'algae'→@ and 'conta'→! in $(basename "$infile")..."
+  sed -E 's/algae/@/g; s/conta/!/g' "$infile" > "$outfile"
+  echo "   ✔ Wrote $outfile"
+}
+
+convert_tags "$alg_out" "$alg_out_tagged"
+convert_tags "$bac_out" "$bac_out_tagged"
+
+# ---------------------- Metrics ----------------------
+echo -e "\n→ Generating metrics report..."
+singularity exec \
+  -B "$METRICS_SCRIPT:/metrics.py" \
+  -B "$(pwd):/workdir" \
+  "$SIF" \
+  bash -c "source /opt/conda/etc/profile.d/conda.sh && \
+           conda activate la4sr && cd /workdir && \
+           python3 /metrics.py \
+             \"$alg_out_tagged\" \"$bac_out_tagged\" \
+             -o \"$report\" \
+             -m \"$miscl\" \
+             -v \
+             -p \"results/$prefix\""
+
+# ---------------------- Finished ----------------------
+echo -e '\n🎉 Done! Results in ./results/'
+echo "  Algal TSV:      $alg_out_tagged"
+echo "  Bact TSV:       $bac_out_tagged"
+echo "  Report:         $report"
+echo "  Misclassified:  $miscl"
+echo "  Plots:          results/${prefix}_*.png"
+

run_la4sr_loop.sbatch

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+#SBATCH -o slurm-logs/arrayJob_%A_%a.out
+#SBATCH -e slurm-logs/arrayJob_%A_%a.err
+#SBATCH -a 1-12  #5-112  # <-- set to length of the *longer* file
+#SBATCH --mem=40G
+#SBATCH --time=12:00:00
+#SBATCH -p nvidia
+#SBATCH --gres=gpu:1
+#SBATCH --cpus-per-task=20
+
+# Get line count of each file
+NUM_ALGAE=$(wc -l < algae-filelist.txt)
+NUM_CONTAM=$(wc -l < contam-filelist.txt)
+
+# Use raw SLURM task ID
+TASK_ID=$SLURM_ARRAY_TASK_ID
+
+# Modulo wrap if needed
+IDX_ALGAE=$(( (TASK_ID - 1) % NUM_ALGAE + 1 ))
+IDX_CONTAM=$(( (TASK_ID - 1) % NUM_CONTAM + 1 ))
+
+# Extract lines from files
+ALINE=$(sed -n "${IDX_ALGAE}p" algae-filelist.txt)
+CLINE=$(sed -n "${IDX_CONTAM}p" contam-filelist.txt)
+
+# Run your classification script
+./run_la4sr_TI-inc-algaGPT.sh resume "$ALINE" "$CLINE"
+
+## EXAMPLE:
+
+##./run_la4sr.sh ./test-data/TI-free/AlgalTop10000-10holdout-headed.fa ./test-data/TI-free/BactTop10000-10holdout-headed.fa

slurm-10718799.out

@@ -0,0 +1,193 @@
+algae-filelist.txt
+cache/
+ckpt.pt
+contam-filelist.txt
+filelist.txt
+generated_prompts_algae1.txt_headed.fa
+generated_prompts_algae2.txt_headed.fa
+generated_prompts_algae3.txt_headed.fa
+generated_prompts_archa1.txt_headed.fa
+generated_prompts_archa2.txt_headed.fa
+generated_prompts_archa3.txt_headed.fa
+generated_prompts_bact1.txt_headed.fa
+generated_prompts_bact2.txt_headed.fa
+generated_prompts_bact3.txt_headed.fa
+generated_prompts_fungi1.txt_headed.fa
+generated_prompts_fungi2.txt_headed.fa
+generated_prompts_fungi3.txt_headed.fa
+generated_prompts_virus1.txt_headed.fa
+generated_prompts_virus2.txt_headed.fa
+generated_prompts_virus3.txt_headed.fa
+infer_TI-inc-algaGPT.py
+la4sr_sp2.sif
+la4sr_sp2.sif.md5
+llm-metrics-two-files.py
+meta.pkl
+model.py
+out-algaGPT/
+__pycache__/
+__pycache__/model.cpython-312.pyc
+README.txt
+results-archive/
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_bact3.txt_headed_misclassified.txt
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_virus3.txt_headed_bacterial_tagged.tsv
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_fungi2.txt_headed_metrics_by_class.png
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_archa2.txt_headed_confusion_matrix.png
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_bact3.txt_headed_algal_tagged.tsv
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_bact2.txt_headed_report.txt
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_fungi3.txt_headed_algal.tsv
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_bact1.txt_headed_algal_tagged.tsv
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_archa3.txt_headed_metrics_by_class.png
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_fungi3.txt_headed_report.txt
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_virus3.txt_headed_bacterial.tsv
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_virus2.txt_headed_bacterial.tsv
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_virus3.txt_headed_algal.tsv
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_bact1.txt_headed_metrics_by_class.png
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_bact1.txt_headed_bacterial.tsv
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_fungi2.txt_headed_class_distribution.png
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_archa2.txt_headed_metrics_by_class.png
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_archa1.txt_headed_misclassified.txt
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_bact2.txt_headed_algal.tsv
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_virus1.txt_headed_bacterial.tsv
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_virus1.txt_headed_metrics_by_class.png
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_virus1.txt_headed_class_distribution.png
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_archa1.txt_headed_bacterial_tagged.tsv
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_bact3.txt_headed_metrics_by_class.png
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_fungi3.txt_headed_misclassified.txt
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_virus2.txt_headed_confusion_matrix.png
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_fungi1.txt_headed_class_distribution.png
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_virus1.txt_headed_algal.tsv
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_fungi3.txt_headed_confusion_matrix.png
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_archa2.txt_headed_bacterial_tagged.tsv
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_archa1.txt_headed_bacterial.tsv
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_fungi3.txt_headed_bacterial_tagged.tsv
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_bact3.txt_headed_bacterial.tsv
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_virus3.txt_headed_class_distribution.png
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_fungi1.txt_headed_misclassified.txt
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_virus3.txt_headed_report.txt
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_archa2.txt_headed_algal_tagged.tsv
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_archa3.txt_headed_class_distribution.png
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_archa1.txt_headed_class_distribution.png
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_virus2.txt_headed_misclassified.txt
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_bact1.txt_headed_bacterial_tagged.tsv
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_archa2.txt_headed_algal.tsv
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_fungi1.txt_headed_algal.tsv
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_virus2.txt_headed_class_distribution.png
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_fungi2.txt_headed_algal_tagged.tsv
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_virus1.txt_headed_bacterial_tagged.tsv
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_archa3.txt_headed_bacterial.tsv
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_virus1.txt_headed_report.txt
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_bact3.txt_headed_algal.tsv
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_archa1.txt_headed_algal.tsv
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_virus2.txt_headed_metrics_by_class.png
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_fungi2.txt_headed_algal.tsv
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_bact1.txt_headed_algal.tsv
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_fungi3.txt_headed_class_distribution.png
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_archa2.txt_headed_class_distribution.png
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_bact2.txt_headed_bacterial.tsv
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_bact3.txt_headed_class_distribution.png
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_virus3.txt_headed_algal_tagged.tsv
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_fungi3.txt_headed_algal_tagged.tsv
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_virus2.txt_headed_algal_tagged.tsv
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_archa1.txt_headed_algal_tagged.tsv
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_fungi2.txt_headed_confusion_matrix.png
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_virus2.txt_headed_algal.tsv
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_fungi1.txt_headed_algal_tagged.tsv
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_archa3.txt_headed_report.txt
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_archa2.txt_headed_report.txt
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_archa3.txt_headed_algal.tsv
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_archa2.txt_headed_misclassified.txt
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_virus1.txt_headed_misclassified.txt
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_fungi1.txt_headed_report.txt
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_bact1.txt_headed_report.txt
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_fungi2.txt_headed_misclassified.txt
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_virus2.txt_headed_report.txt
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_archa1.txt_headed_metrics_by_class.png
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_bact2.txt_headed_confusion_matrix.png
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_bact2.txt_headed_misclassified.txt
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_archa2.txt_headed_bacterial.tsv
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_fungi2.txt_headed_bacterial_tagged.tsv
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_bact2.txt_headed_bacterial_tagged.tsv
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_virus3.txt_headed_metrics_by_class.png
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_bact2.txt_headed_class_distribution.png
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_fungi2.txt_headed_bacterial.tsv
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_archa3.txt_headed_bacterial_tagged.tsv
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_archa1.txt_headed_report.txt
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_virus2.txt_headed_bacterial_tagged.tsv
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_bact1.txt_headed_class_distribution.png
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_bact1.txt_headed_confusion_matrix.png
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_virus3.txt_headed_confusion_matrix.png
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_virus1.txt_headed_algal_tagged.tsv
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_bact1.txt_headed_misclassified.txt
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_fungi1.txt_headed_bacterial.tsv
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_fungi3.txt_headed_metrics_by_class.png
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_archa3.txt_headed_algal_tagged.tsv
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_fungi1.txt_headed_bacterial_tagged.tsv
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_bact3.txt_headed_report.txt
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_bact3.txt_headed_bacterial_tagged.tsv
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_fungi1.txt_headed_confusion_matrix.png
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_fungi1.txt_headed_metrics_by_class.png
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_bact2.txt_headed_metrics_by_class.png
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_archa3.txt_headed_confusion_matrix.png
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_virus1.txt_headed_confusion_matrix.png
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_archa3.txt_headed_misclassified.txt
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_bact2.txt_headed_algal_tagged.tsv
+results-archive/generated_prompts_algae1.txt_headed_vs_generated_prompts_archa1.txt_headed_confusion_matrix.png
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_virus3.txt_headed_misclassified.txt
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_fungi3.txt_headed_bacterial.tsv
+results-archive/generated_prompts_algae2.txt_headed_vs_generated_prompts_fungi2.txt_headed_report.txt
+results-archive/generated_prompts_algae3.txt_headed_vs_generated_prompts_bact3.txt_headed_confusion_matrix.png
+run_la4sr_loop.sbatch
+run_la4sr_TI-inc-algaGPT.sh
+slurm-10718799.out
+tar: slurm-10718799.out: file changed as we read it
+slurm-logs/
+slurm-logs/arrayJob_10718778_2.err
+slurm-logs/arrayJob_10718764_10.err
+slurm-logs/arrayJob_10718778_8.err
+slurm-logs/arrayJob_10718778_7.err
+slurm-logs/arrayJob_10718764_9.out
+slurm-logs/arrayJob_10718778_11.out
+slurm-logs/arrayJob_10718764_4.err
+slurm-logs/arrayJob_10718778_9.err
+slurm-logs/arrayJob_10718764_10.out
+slurm-logs/arrayJob_10718778_6.err
+slurm-logs/arrayJob_10718778_1.err
+slurm-logs/arrayJob_10718764_11.out
+slurm-logs/arrayJob_10718778_12.out
+slurm-logs/arrayJob_10718778_9.out
+slurm-logs/arrayJob_10718764_11.err
+slurm-logs/arrayJob_10718778_10.out
+slurm-logs/arrayJob_10718764_9.err
+slurm-logs/arrayJob_10718764_2.out
+slurm-logs/arrayJob_10718778_2.out
+slurm-logs/arrayJob_10718778_5.out
+slurm-logs/arrayJob_10718764_12.out
+slurm-logs/arrayJob_10718764_1.err
+slurm-logs/arrayJob_10718764_8.err
+slurm-logs/arrayJob_10718764_3.err
+slurm-logs/arrayJob_10718778_1.out
+slurm-logs/arrayJob_10718764_2.err
+slurm-logs/arrayJob_10718778_10.err
+slurm-logs/arrayJob_10718778_3.err
+slurm-logs/arrayJob_10718778_5.err
+slurm-logs/arrayJob_10718778_8.out
+slurm-logs/arrayJob_10718778_4.out
+slurm-logs/arrayJob_10718764_7.err
+slurm-logs/arrayJob_10718778_3.out
+slurm-logs/arrayJob_10718778_12.err
+slurm-logs/arrayJob_10718764_3.out
+slurm-logs/arrayJob_10718764_6.out
+slurm-logs/arrayJob_10718764_5.err
+slurm-logs/arrayJob_10718778_7.out
+slurm-logs/arrayJob_10718764_7.out
+slurm-logs/arrayJob_10718764_4.out
+slurm-logs/arrayJob_10718764_6.err
+slurm-logs/arrayJob_10718778_4.err
+slurm-logs/arrayJob_10718764_5.out
+slurm-logs/arrayJob_10718778_6.out
+slurm-logs/arrayJob_10718764_1.out
+slurm-logs/arrayJob_10718764_8.out
+slurm-logs/arrayJob_10718764_12.err
+slurm-logs/arrayJob_10718778_11.err
+targz.sh

targz.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+#SBATCH --mem=90GB
+#SBATCH --time=96:00:00
+#SBATCH --cpus-per-task=12
+
+#tar -zcvf la4sr.tar.gz la4sr_sp* run_la4sr.sh run_la4sr.sbatch run_la4sr_loop.sbatch infer-ByT5tok-attn-fastaParser.py llm-metrics-two-files.py examples/Nannochloris_eucaryotum.AAC.fa.aa.fa examples/GCF_900016285.2_ANSES_11-930-9S.fa
+tar -zcvf la4sr-TI-inc-algaGPT.tar.gz *
+