Upload folder using huggingface_hub

.gitattributes

@@ -9,7 +9,6 @@
 *.joblib filter=lfs diff=lfs merge=lfs -text
 *.lfs.* filter=lfs diff=lfs merge=lfs -text
 *.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
 *.mlmodel filter=lfs diff=lfs merge=lfs -text
 *.model filter=lfs diff=lfs merge=lfs -text
 *.msgpack filter=lfs diff=lfs merge=lfs -text
@@ -54,6 +53,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+pinnacle_embeds/pinnacle_labels_dict.txt filter=lfs diff=lfs merge=lfs -text
+*.psd filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text
+depmap_24q2 filter=lfs diff=lfs merge=lfs -text
+*.h5ad filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,85 @@
----
-license: apache-2.0
----
+---
+configs:
+- config_name: labels_dict
+  data_files:
+  - path: pinnacle_embeds/pinnacle_labels_dict.txt
+    split: train
+- config_name: pinnacle_protein_embed
+  data_files:
+  - path: pinnacle_embeds/pinnacle_protein_embed.pth
+    split: train
+license: apache-2.0
+language:
+- en
+tags:
+- chemistry
+pretty_name: medea_db
+---
+
+# MEDEA-DB 
+
+This database contains curated datasets and pre-trained model weights across multiple domains of tools leveraged by Medea, including:
+
+- Protein-protein interaction networks & Multi-scale gene/protein embeddings (PINNACLE, TranscriptFormer, etc.)
+- Co-dependency statistics for disease gene pair (Chronos gene-effect profiles from DepMap 24Q2 CRISPR)
+- Immunotherapy response prediction models (COMPASS pretrain checkpoint)
+
+---
+
+## Available Data & Resources
+
+### 1. Gene/Protein Embeddings
+
+#### **PINNACLE Embeddings** (`pinnacle_embeds/`)
+- **Model**: PINNACLE
+- **Files**:
+  - `pinnacle_protein_embed.pth`: Protein-level embeddings with cell type specificity
+  - `pinnacle_mg_embed.pth`: Meta-graph level embeddings on cellular interactions and tissue hierarchy
+  - `ppi_embed_dict.pth`: PPI-based embeddings
+  - `pinnacle_labels_dict.txt`: Gene/protein labels
+- **Config Names**: `pinnacle_protein_embed`, `labels_dict`
+- **Format**: PyTorch tensors
+
+#### **Transcriptformer Embeddings** (`transcriptformer_embedding/`)
+- **Model**: Transcriptformer (Transcriptomics transformer)
+- **Structure**:
+  - `embedding_generation/`: Scripts for generating embeddings
+  - `embedding_store/`: Pre-computed embeddings (138 `.npy` files)
+  - `processor/`: Data processing utilities
+- **Format**: NumPy arrays, compressed archives
+
+---
+
+### 2. Gene Dependency & Correlation Data
+
+#### **DepMap 24Q2** (`depmap_24q2/`)
+- **Release**: DepMap Public 24Q2
+- **Files**:
+  - `corr_matrix.npy`: Gene correlation matrix
+  - `p_val_matrix.npy`: Statistical significance values
+  - `p_adj_matrix.npy`: Adjusted p-values (multiple testing correction)
+  - `gene_correlations.h5`: HDF5 format correlations
+  - `gene_idx_array.npy`: Gene index mappings
+  - `gene_names.txt`: Gene identifiers
+
+---
+
+### 3. Immunotherapy Response Prediction Models
+
+#### **COMPASS Checkpoints** (`compass/checkpoint/`)
+- **Model**: COMPASS
+- **Checkpoints**:
+  - `pretrainer.pt`: Pre-trained base model
+  - `pft_leave_IMVigor210.pt`: Leave-one-cohort-out (IMVigor210) fintuned model   
+
+---
+
+## Data Sources & Citations
+
+Please cite the original sources when using specific datasets or models.
+
+---
+
+## License
+
+This dataset is released under the [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) license.

compass/checkpoint/pft_leave_IMVigor210.pt

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

compass/checkpoint/pretrainer.pt

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

depmap_24q2/corr_matrix.npy

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

depmap_24q2/gene_correlations.h5

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

depmap_24q2/gene_idx_array.npy

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

depmap_24q2/p_adj_matrix.npy

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

depmap_24q2/p_val_matrix.npy

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

pinnacle_embeds/pinnacle_labels_dict.txt

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

pinnacle_embeds/pinnacle_mg_embed.pth

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

pinnacle_embeds/pinnacle_protein_embed.pth

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

pinnacle_embeds/ppi_embed_dict.pth

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

transcriptformer_embedding/embedding_generation/README.md

@@ -0,0 +1,23 @@
+## Step 1 - Download TranscriptFormer
+git clone https://github.com/czi-ai/transcriptformer.git
+
+## Step 2 - Create a local folder structure
+Disease-atlas/
+|-- fl
+|   `-- fixed.h5ad
+|-- ra
+|   |-- e04346ba-cdc5-418b-81e6-2f896696e3dd.h5ad
+|   `-- fixed.h5ad
+|-- ss
+|   |-- 4e6c8033-87d5-45e6-a240-10281074d440.h5ad
+|   `-- fixed.h5ad
+`-- t1dm
+    |-- 5378ac26-e216-41e8-b171-a7f4d819a9ff.h5ad
+    `-- fixed.h5ad
+    
+## Step 3 - Download and Check the Disease Atlas
+python preprocess_adata.py /root/Disease-atlas/t1dm/5378ac26-e216-41e8-b171-a7f4d819a9ff.h5ad /root/Disease-atlas
+/t1dm/fixed.h5ad
+
+## Step 4 - Run Inference
+python celltype_disease_cge_inference.py /root/Disease-atlas/t1dm/fixed.h5ad t1dm_cge_embeddings.h5ad ~/transcriptformer/checkpoints/tf_sapiens/ 1000 100 1

transcriptformer_embedding/embedding_generation/celltype_disease_cge_inference.py

@@ -0,0 +1,586 @@
+#!/usr/bin/env python3
+"""
+Cell-type and Disease-state specific CGE inference.
+Generates separate averaged embeddings for each cell-type + disease-state combination.
+"""
+
+import sys
+import os
+import gc
+import numpy as np
+import pandas as pd
+import anndata as ad
+import subprocess
+import tempfile
+from pathlib import Path
+import shutil
+import time
+from collections import defaultdict
+from joblib import Parallel, delayed
+import re
+
+def check_disk_space():
+    """Check available disk space."""
+    try:
+        usage = shutil.disk_usage('/')
+        free_gb = usage.free / (1024**3)
+        return free_gb
+    except:
+        return 0
+
+def analyze_cell_groups(adata):
+    """Analyze cell type and disease state combinations."""
+    
+    print("🔍 Analyzing Cell Groups")
+    print("=" * 40)
+    
+    # Get unique combinations
+    groups = adata.obs.groupby(['cell_type', 'disease']).size().reset_index(name='cell_count')
+    groups = groups.sort_values('cell_count', ascending=False)
+    
+    print(f"📊 Found {len(groups)} cell-type + disease combinations:")
+    print("-" * 50)
+    
+    memory_estimates = []
+    groups_needing_chunks = 0
+    
+    for _, row in groups.iterrows():
+        cell_type = row['cell_type']
+        disease = row['disease']
+        count = row['cell_count']
+        percentage = (count / adata.n_obs) * 100
+        
+        # Memory estimate (float32 = 4 bytes per value)
+        memory_mb = (count * adata.n_vars * 4) / (1024**2) if count > 0 else 0
+        memory_estimates.append(memory_mb)
+        
+        # Check if chunking needed
+        needs_chunking = memory_mb > 2000
+        if needs_chunking:
+            groups_needing_chunks += 1
+        
+        chunk_symbol = "🔸" if needs_chunking else "🔹"
+        print(f"  {chunk_symbol} {cell_type} ({disease}): {count:,} cells ({percentage:.1f}%) - ~{memory_mb:.1f} MB")
+    
+    print()
+    print("🧠 Memory-Adaptive Processing Strategy:")
+    print(f"   • Groups processed as single units: {len(groups) - groups_needing_chunks}/{len(groups)}")
+    print(f"   • Groups requiring chunking: {groups_needing_chunks}/{len(groups)}")
+    print(f"   • Memory threshold: 2GB per chunk")
+    
+    return groups
+
+def get_cell_indices_for_group(adata, cell_type, disease):
+    """Get cell indices for a specific cell-type + disease combination."""
+    mask = (adata.obs['cell_type'] == cell_type) & (adata.obs['disease'] == disease)
+    indices = np.where(mask)[0]
+    return indices
+
+def create_chunk(adata, cell_indices, chunk_start, chunk_end, chunk_path):
+    """Create a chunk from specific cell indices."""
+    
+    # Get the actual indices for this chunk
+    chunk_indices = cell_indices[chunk_start:chunk_end]
+    
+    # Create chunk from these specific cells
+    chunk_adata = adata[chunk_indices, :].copy()
+    chunk_adata.write(chunk_path)
+    
+    size_mb = os.path.getsize(chunk_path) / (1024**2)
+    print(f"     📦 Chunk file: {size_mb:.1f} MB ({len(chunk_indices)} cells)")
+    
+    return len(chunk_indices)
+
+def run_inference_chunk(chunk_path, output_path, checkpoint_path, batch_size=1, max_retries=3):
+    """Run inference on a single chunk with automatic batch size reduction."""
+    
+    abs_checkpoint_path = os.path.abspath(checkpoint_path)
+    abs_chunk_path = os.path.abspath(chunk_path)
+    output_dir = os.path.dirname(output_path)
+    
+    # Debug information
+    print(f"     🐛 Debug info:")
+    print(f"        Checkpoint: {abs_checkpoint_path}")
+    print(f"        Input: {abs_chunk_path}")
+    print(f"        Output dir: {output_dir}")
+    print(f"        Expected output: {output_path}")
+    
+    # Try with automatic batch size reduction
+    current_batch_size = batch_size
+    
+    for attempt in range(max_retries):
+        # Update command with current batch size
+        cmd = [
+            "transcriptformer", "inference",
+            "--checkpoint-path", abs_checkpoint_path,
+            "--data-file", abs_chunk_path,
+            "--emb-type", "cge",
+            "--output-filename", os.path.basename(output_path),
+            "--batch-size", str(current_batch_size),
+            "--precision", "16-mixed"
+        ]
+        
+        print(f"     🚀 Command: {' '.join(cmd)}")
+        print(f"     📦 Attempt {attempt + 1}/{max_retries} with batch_size={current_batch_size}")
+        
+        try:
+            # Run with real-time streaming output
+            print(f"     🔍 Starting transcriptformer inference...")
+            print(f"     📺 Streaming logs (press Ctrl+C to stop):")
+            print(f"     {'='*50}")
+            
+            # Use Popen for real-time streaming
+            process = subprocess.Popen(
+                cmd, 
+                cwd=output_dir, 
+                stdout=subprocess.PIPE, 
+                stderr=subprocess.STDOUT,  # Combine stderr into stdout
+                text=True, 
+                bufsize=1,  # Line buffered
+                universal_newlines=True
+            )
+            
+            # Stream output in real-time
+            stdout_lines = []
+            stderr_lines = []
+            
+            try:
+                while True:
+                    output = process.stdout.readline()
+                    if output == '' and process.poll() is not None:
+                        break
+                    if output:
+                        # Print in real-time with prefix
+                        print(f"     📺 {output.rstrip()}")
+                        stdout_lines.append(output)
+            except KeyboardInterrupt:
+                print(f"     ⚠️  Process interrupted by user")
+                process.terminate()
+                process.wait()
+                return False
+            
+            # Wait for process to complete
+            return_code = process.wait()
+            
+            print(f"     {'='*50}")
+            print(f"     📊 Process completed with return code: {return_code}")
+            
+            # Store result for compatibility
+            result = type('Result', (), {
+                'returncode': return_code,
+                'stdout': ''.join(stdout_lines),
+                'stderr': ''.join(stderr_lines)
+            })()
+            
+            if result.returncode == 0:
+                # Check for output file in multiple possible locations
+                possible_outputs = []
+                
+                # 1. Check in inference_results subdirectory (original expectation)
+                inference_results_output = os.path.join(output_dir, "inference_results", os.path.basename(output_path))
+                possible_outputs.append(inference_results_output)
+                
+                # 2. Check directly in output directory
+                direct_output = os.path.join(output_dir, os.path.basename(output_path))
+                possible_outputs.append(direct_output)
+                
+                # 3. Check for .h5ad files in output directory (in case filename differs)
+                if os.path.exists(output_dir):
+                    for file in os.listdir(output_dir):
+                        if file.endswith('.h5ad'):
+                            possible_outputs.append(os.path.join(output_dir, file))
+                
+                # 4. Check for .h5ad files in inference_results subdirectory
+                inference_dir = os.path.join(output_dir, "inference_results")
+                if os.path.exists(inference_dir):
+                    for file in os.listdir(inference_dir):
+                        if file.endswith('.h5ad'):
+                            possible_outputs.append(os.path.join(inference_dir, file))
+                
+                # Try to find the actual output file
+                print(f"     🔍 Searching for output files...")
+                found_output = None
+                for i, possible_output in enumerate(possible_outputs):
+                    exists = os.path.exists(possible_output)
+                    print(f"     {i+1:2d}. {possible_output} {'✅' if exists else '❌'}")
+                    if exists:
+                        found_output = possible_output
+                        break
+                
+                if found_output:
+                    print(f"     ✅ Found output: {found_output}")
+                    # Move to expected location if different
+                    if found_output != output_path:
+                        shutil.move(found_output, output_path)
+                        print(f"     📁 Moved to: {output_path}")
+                    
+                    # Clean up inference_results directory if it exists
+                    if os.path.exists(inference_dir):
+                        shutil.rmtree(inference_dir)
+                        print(f"     🧹 Cleaned up inference_results directory")
+                    
+                    return True
+                else:
+                    print(f"     ❌ Output not found in any expected location")
+                    print(f"     🔍 Searched locations:")
+                    for loc in possible_outputs:
+                        print(f"        • {loc} {'✅' if os.path.exists(loc) else '❌'}")
+                    
+                    # List all files in output directory for debugging
+                    if os.path.exists(output_dir):
+                        print(f"     📁 All files in output_dir: {os.listdir(output_dir)}")
+                        # Check for subdirectories
+                        for item in os.listdir(output_dir):
+                            item_path = os.path.join(output_dir, item)
+                            if os.path.isdir(item_path):
+                                print(f"     📁 Subdirectory '{item}': {os.listdir(item_path)}")
+                    
+                    return False
+            else:
+                if result.returncode == -9:
+                    print(f"     ❌ Process killed by system (SIGKILL) - likely out of memory")
+                    print(f"     💡 Reducing batch size and retrying...")
+                    current_batch_size = max(1, current_batch_size // 2)
+                    continue
+                elif result.returncode == -11:
+                    print(f"     ❌ Process crashed with segmentation fault")
+                    return False
+                else:
+                    print(f"     ❌ Inference failed (code {result.returncode})")
+                    return False
+                    
+        except subprocess.TimeoutExpired:
+            print(f"     ❌ Inference timed out")
+            return False
+        except Exception as e:
+            print(f"     ❌ Error: {str(e)}")
+            return False
+    
+    print(f"     ❌ All {max_retries} attempts failed")
+    return False
+
+def load_cge_embeddings(chunk_path):
+    """Load CGE embeddings from a chunk result."""
+    try:
+        chunk_adata = ad.read_h5ad(chunk_path)
+        
+        if 'cge_embeddings' not in chunk_adata.uns:
+            print(f"     ⚠️  No CGE embeddings found")
+            return None, None, None
+        
+        embeddings = chunk_adata.uns['cge_embeddings']
+        gene_names = chunk_adata.uns.get('cge_gene_names', None)
+        cell_indices = chunk_adata.uns.get('cge_cell_indices', None)
+        
+        print(f"     📊 Loaded: {embeddings.shape[0]} embeddings, {embeddings.shape[1]} dims")
+        
+        return embeddings, gene_names, cell_indices
+        
+    except Exception as e:
+        print(f"     ❌ Error loading embeddings: {e}")
+        return None, None, None
+
+def merge_cge_embeddings(running_avg, running_counts, new_embeddings, new_gene_names):
+    """
+    Incrementally update running average of CGE embeddings using a much faster,
+    pandas-based vectorized approach.
+    """
+    if running_avg is None:
+        running_avg = {}
+        running_counts = {}
+
+    if len(new_gene_names) == 0:
+        return running_avg, running_counts
+
+    # Create a DataFrame for efficient processing
+    df = pd.DataFrame({
+        'gene': new_gene_names,
+        'embedding': list(new_embeddings)
+    })
+
+    # Group by gene and aggregate embeddings
+    # - Sum all embeddings for each gene
+    # - Count occurrences of each gene
+    agg_df = df.groupby('gene')['embedding'].agg(['sum', 'count'])
+
+    # Update running averages
+    for gene, row in agg_df.iterrows():
+        gene_str = str(gene)
+        gene_sum = row['sum']
+        n_new = row['count']
+
+        if gene_str in running_avg:
+            old_avg = running_avg[gene_str]
+            old_count = running_counts[gene_str]
+            
+            new_count = old_count + n_new
+            # Efficiently calculate the new average
+            running_avg[gene_str] = old_avg * (old_count / new_count) + gene_sum / new_count
+            running_counts[gene_str] = new_count
+        else:
+            # This is a new gene
+            running_avg[gene_str] = gene_sum / n_new
+            running_counts[gene_str] = n_new
+            
+    return running_avg, running_counts
+
+def process_cell_group(adata, cell_type, disease, cell_indices, checkpoint_path,
+                     temp_dir, chunk_size=500, batch_size=1, memory_threshold_mb=2000):
+    """
+    Process a single cell-type + disease group with simplified, more efficient adaptive chunking.
+    """
+    print(f"\n🎯 Processing: {cell_type} ({disease})")
+    print(f"   📊 {len(cell_indices)} cells")
+    print("-" * 50)
+
+    if len(cell_indices) == 0:
+        print("   ⚠️  No cells to process")
+        return None, None, 0
+
+    # Simplified chunking logic
+    n_cells = len(cell_indices)
+    # Estimate memory based on a sample, assuming float32
+    est_mem_per_cell = (adata.n_vars * 4) / (1024**2)
+    est_total_mem = n_cells * est_mem_per_cell
+
+    chunk_size = 1000
+    n_chunks = int(np.ceil(n_cells / chunk_size))
+    print(f"   ⚠️  Large group, using {n_chunks} chunks of ~{chunk_size} cells.")
+
+    running_avg, running_counts = None, None
+    total_cells_processed, successful_chunks = 0, 0
+
+    for i in range(n_chunks):
+        start_idx, end_idx = i * chunk_size, min((i + 1) * chunk_size, n_cells)
+        
+        if n_chunks > 1:
+            print(f"   🔄 Chunk {i+1}/{n_chunks} ({end_idx - start_idx} cells)")
+
+        if check_disk_space() < 3:
+            print(f"   🚨 STOPPING: Low disk space.")
+            break
+
+        # Create a safe group name for file naming
+        group_name = re.sub(r'[^\w.-]+', '_', f"{cell_type}_{disease}")
+        group_name = group_name.replace(" ", "_").replace("-", "_").lower()
+        # Truncate if too long, but ensure uniqueness by adding a hash
+        # if len(group_name) > 40:
+        #     import hashlib
+        #     hash_suffix = hashlib.md5(group_name.encode()).hexdigest()[:8]
+        #     group_name = group_name[:32] + "_" + hash_suffix
+        chunk_input = os.path.join(temp_dir, f"{group_name}_chunk_{i}_input.h5ad")
+        chunk_output_dir = os.path.join(temp_dir, f"{group_name}_chunk_{i}_output")
+        chunk_output = os.path.join(chunk_output_dir, f"{group_name}_chunk_{i}_cge.h5ad")
+        os.makedirs(chunk_output_dir, exist_ok=True)
+
+        actual_cells = create_chunk(adata, cell_indices, start_idx, end_idx, chunk_input)
+        
+        success = run_inference_chunk(chunk_input, chunk_output, checkpoint_path, batch_size)
+
+        if success and os.path.exists(chunk_output):
+            embeddings, gene_names, _ = load_cge_embeddings(chunk_output)
+            if embeddings is not None and gene_names is not None:
+                running_avg, running_counts = merge_cge_embeddings(
+                    running_avg, running_counts, embeddings, gene_names
+                )
+                total_cells_processed += actual_cells
+                successful_chunks += 1
+                print(f"     ✅ Chunk {i+1} merged (running genes: {len(running_avg)})")
+            else:
+                print(f"     ❌ Chunk {i+1} - no valid embeddings found.")
+        else:
+            print(f"     ❌ Chunk {i+1} failed.")
+
+        # Cleanup
+        if os.path.exists(chunk_input): os.remove(chunk_input)
+        if os.path.exists(chunk_output_dir): shutil.rmtree(chunk_output_dir)
+        gc.collect()
+
+    print(f"   ✅ Group completed: {successful_chunks}/{n_chunks} chunks processed, {total_cells_processed} cells.")
+    
+    return (running_avg, running_counts, total_cells_processed) if running_avg else (None, None, 0)
+
+def save_celltype_disease_embeddings(all_group_embeddings, output_path, original_adata):
+    """
+    Save all cell-type + disease specific embeddings using a more efficient,
+    vectorized approach.
+    """
+    print(f"\n💾 Saving Cell-Type + Disease Specific CGE Embeddings")
+    print("=" * 60)
+
+    # Create master gene list from all groups
+    all_genes = sorted(list(set.union(*(set(d[0].keys()) for d in all_group_embeddings.values() if d[0]))))
+    gene_to_idx = {gene: i for i, gene in enumerate(all_genes)}
+    print(f"   📊 Total unique genes across all groups: {len(all_genes)}")
+
+    # Prepare group metadata
+    group_keys = list(all_group_embeddings.keys())
+    
+    # Create unique group names
+    group_names = []
+    seen_names = set()
+    for ct, ds in group_keys:
+        ct = ct.replace(" ", "_").replace("-", "_").replace(".", "_").replace(",", "_").lower()
+        ds = ds.replace(" ", "_").replace("-", "_").replace(".", "_").replace(",", "_").lower()
+        base_name = re.sub(r'[^\w.-]+', '_', f"{ct}_{ds}")  # Leave room for suffix
+        name = base_name
+        counter = 1
+        while name in seen_names:
+            name = f"{base_name}_{counter}"
+            counter += 1
+        seen_names.add(name)
+        group_names.append(name)
+    
+    var_data = pd.DataFrame({
+        'cell_type': [k[0] for k in group_keys],
+        'disease_state': [k[1] for k in group_keys],
+        'group_name': group_names,
+        'total_cells': [all_group_embeddings[k][2] for k in group_keys]
+    }, index=group_names)
+
+    # Get embedding dimension
+    first_valid_group = next((g for g in all_group_embeddings.values() if g[0]), None)
+    if not first_valid_group:
+        print("   ⚠️ No valid embeddings found to save.")
+        return None
+    embedding_dim = len(next(iter(first_valid_group[0].values())))
+
+    # Efficiently create embedding and count matrices
+    n_genes = len(all_genes)
+    n_groups = len(group_keys)
+    
+    # Initialize matrices
+    all_embeddings = np.zeros((n_groups, n_genes, embedding_dim), dtype=np.float32)
+    all_counts = np.zeros((n_groups, n_genes), dtype=np.int32)
+
+    for i, group_key in enumerate(group_keys):
+        running_avg, running_counts, _ = all_group_embeddings[group_key]
+        if not running_avg:
+            continue
+        
+        print(f"   📋 Processing group: {group_names[i]}")
+        
+        # Get gene indices for this group
+        group_genes = list(running_avg.keys())
+        indices = [gene_to_idx[g] for g in group_genes]
+        
+        # Directly place data into pre-allocated arrays
+        all_embeddings[i, indices, :] = np.array(list(running_avg.values()))
+        all_counts[i, indices] = np.array(list(running_counts.values()))
+
+    # Create comprehensive AnnData object
+    obs_data = pd.DataFrame(index=all_genes)
+    final_adata = ad.AnnData(X=np.zeros((n_genes, n_groups)), obs=obs_data, var=var_data)
+
+    # Store embeddings and counts in uns
+    final_adata.uns['celltype_disease_embeddings'] = {
+        group_name: all_embeddings[i] for i, group_name in enumerate(group_names)
+    }
+    final_adata.uns['celltype_disease_counts'] = {
+        group_name: all_counts[i] for i, group_name in enumerate(group_names)
+    }
+    
+    # Store metadata
+    final_adata.uns['gene_names'] = all_genes
+    final_adata.uns['group_info'] = var_data.to_dict('index')
+    final_adata.uns['original_data_shape'] = list(original_adata.shape)
+    final_adata.uns['averaging_method'] = 'celltype_disease_specific'
+    final_adata.uns['embedding_dimensions'] = embedding_dim
+
+    # Save
+    final_adata.write(output_path)
+    file_size = os.path.getsize(output_path) / (1024**2)
+    print(f"   💾 Final file size: {file_size:.1f} MB")
+
+    # Summary
+    print(f"\n📋 Summary:")
+    print(f"   • {n_genes:,} genes")
+    print(f"   • {n_groups} cell-type + disease groups")
+    print(f"   • {embedding_dim} embedding dimensions")
+    print(f"   • File: {output_path}")
+    
+    return output_path
+
+def celltype_disease_cge_inference(input_path, output_path, checkpoint_path,
+                                  chunk_size=500, batch_size=1, n_jobs=-1):
+    """
+    Run cell-type and disease-state specific CGE inference with parallel processing.
+    """
+    print(f"🧬 Cell-Type + Disease-State Specific CGE Inference (Parallelized)")
+    print(f"   Input: {input_path}")
+    print(f"   Output: {output_path}")
+    print(f"   Parallel Jobs: {n_jobs}")
+    print("=" * 80)
+
+    if check_disk_space() < 10:
+        raise Exception("Insufficient disk space (need at least 10GB)")
+
+    print("📖 Loading AnnData...")
+    adata = ad.read_h5ad(input_path)
+    print(f"✅ Loaded: {adata.shape[0]} cells × {adata.shape[1]} genes")
+
+    groups_df = analyze_cell_groups(adata)
+    
+    output_dir = os.path.dirname(os.path.abspath(output_path))
+    temp_dir = tempfile.mkdtemp(prefix="celltype_disease_cge_", dir=output_dir)
+    print(f"\n📁 Temp directory: {temp_dir}")
+
+    try:
+        tasks = [
+            delayed(process_cell_group)(
+                adata, row['cell_type'], row['disease'],
+                get_cell_indices_for_group(adata, row['cell_type'], row['disease']),
+                checkpoint_path, temp_dir, chunk_size, batch_size
+            ) for _, row in groups_df.iterrows()
+        ]
+
+        results = Parallel(n_jobs=n_jobs)(tasks)
+
+        all_group_embeddings = {
+            (row['cell_type'], row['disease']): result
+            for (_, row), result in zip(groups_df.iterrows(), results) if result[0]
+        }
+
+        if all_group_embeddings:
+            print(f"\n✅ Successfully processed {len(all_group_embeddings)} groups")
+            return save_celltype_disease_embeddings(all_group_embeddings, output_path, adata)
+        else:
+            raise Exception("No valid group embeddings were processed")
+            
+    finally:
+        if os.path.exists(temp_dir):
+            print(f"\n🧹 Cleaning temp directory...")
+            shutil.rmtree(temp_dir)
+
+def main():
+    if len(sys.argv) < 4:
+        print("Usage: python celltype_disease_cge_inference.py <input_h5ad> <output_h5ad> <checkpoint_path> [chunk_size] [batch_size] [n_jobs]")
+        print("Example: python celltype_disease_cge_inference.py data.h5ad cge.h5ad ./ckpt/ 500 1 -1")
+        sys.exit(1)
+    
+    input_path = sys.argv[1]
+    output_path = sys.argv[2]
+    checkpoint_path = sys.argv[3]
+    chunk_size = int(sys.argv[4]) if len(sys.argv) > 4 else 500
+    batch_size = int(sys.argv[5]) if len(sys.argv) > 5 else 1
+    n_jobs = int(sys.argv[6]) if len(sys.argv) > 6 else -1
+    
+    try:
+        result = celltype_disease_cge_inference(
+            os.path.abspath(input_path),
+            os.path.abspath(output_path),
+            os.path.abspath(checkpoint_path),
+            chunk_size,
+            batch_size,
+            n_jobs
+        )
+        print(f"\n🎉 SUCCESS! Cell-type + Disease-state specific CGE embeddings: {result}")
+        
+    except Exception as e:
+        print(f"\n❌ ERROR: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

transcriptformer_embedding/embedding_generation/preprocess_adata.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""
+Consolidated script to diagnose and fix h5ad files for transcriptformer.
+
+This script performs a series of checks to validate an AnnData object and
+automatically applies fixes for common issues, preparing the data for
+inference with transcriptformer.
+
+Usage:
+    python preprocess_adata.py <input_h5ad_file> <output_h5ad_file>
+"""
+
+import sys
+import os
+import numpy as np
+import anndata as ad
+import scanpy as sc
+from pathlib import Path
+
+def preprocess_adata(input_path, output_path):
+    """
+    Diagnose and fix an h5ad file for transcriptformer compatibility.
+    """
+    print(f"🚀 Starting preprocessing for: {input_path}")
+    print("=" * 70)
+
+    # 1. Load Data
+    print("📖 1. Loading AnnData object...")
+    if not os.path.exists(input_path):
+        print(f"❌ ERROR: Input file not found: {input_path}")
+        return False
+    
+    try:
+        adata = ad.read_h5ad(input_path)
+        print(f"✅ Loaded: {adata.shape[0]} cells × {adata.shape[1]} genes")
+    except Exception as e:
+        print(f"❌ ERROR: Could not load AnnData file. Reason: {e}")
+        return False
+
+    original_shape = adata.shape
+
+    # 2. Run Diagnostics
+    print("\n🔬 2. Running Diagnostics...")
+    issues_found = []
+
+    # Check for NaN/Inf values
+    has_nan = np.isnan(adata.X.data).any() if hasattr(adata.X, 'data') else np.isnan(adata.X).any()
+    has_inf = np.isinf(adata.X.data).any() if hasattr(adata.X, 'data') else np.isinf(adata.X).any()
+    if has_nan: issues_found.append("NaN values found in data matrix.")
+    if has_inf: issues_found.append("Infinite values found in data matrix.")
+    print(f"   - NaN/Inf values: {'❌ Found' if has_nan or has_inf else '✅ None'}")
+
+    # Check for unique gene indices
+    if adata.var.index.nunique() < len(adata.var.index):
+        issues_found.append("Duplicate gene indices (var_names) found.")
+        print("   - Duplicate gene indices: ❌ Found")
+    else:
+        print("   - Duplicate gene indices: ✅ Unique")
+
+    # Check for ensembl_id column
+    if 'ensembl_id' not in adata.var.columns:
+        issues_found.append("'ensembl_id' column missing in var.")
+        print("   - 'ensembl_id' column: ❌ Missing")
+    else:
+        print("   - 'ensembl_id' column: ✅ Present")
+
+    # Check for zero-expression genes
+    genes_before_filter = adata.n_vars
+    sc.pp.filter_genes(adata, min_cells=1)
+    if adata.n_vars < genes_before_filter:
+        num_removed = genes_before_filter - adata.n_vars
+        issues_found.append(f"{num_removed} genes with zero expression found.")
+        print(f"   - Zero-expression genes: ❌ Found ({num_removed} genes)")
+    else:
+        print("   - Zero-expression genes: ✅ None")
+    
+    # Restore original object for fixing step
+    adata = ad.read_h5ad(input_path)
+
+    # 3. Apply Fixes
+    print("\n🔧 3. Applying Fixes...")
+    fixes_applied = []
+
+    # Fix: Ensure var_names are unique
+    if adata.var.index.nunique() < len(adata.var.index):
+        adata.var_names_make_unique()
+        fixes_applied.append("Made var_names unique using .var_names_make_unique()")
+        print("   - ✅ Made gene indices (var_names) unique.")
+    else:
+        print("   - ✅ Gene indices are already unique.")
+
+    # Fix: Add ensembl_id column if it's missing
+    if 'ensembl_id' not in adata.var.columns:
+        print("   - Adding 'ensembl_id' column from var.index.")
+        adata.var['ensembl_id'] = adata.var.index
+        fixes_applied.append("Added 'ensembl_id' column from var.index.")
+    else:
+        print("   - ✅ 'ensembl_id' column already exists.")
+
+    # Fix: Filter out genes with zero expression
+    genes_before_filter = adata.n_vars
+    sc.pp.filter_genes(adata, min_cells=1)
+    if adata.n_vars < genes_before_filter:
+        num_removed = genes_before_filter - adata.n_vars
+        fixes_applied.append(f"Removed {num_removed} genes with no expression.")
+        print(f"   - ✅ Removed {num_removed} zero-expression genes.")
+    else:
+        print("   - ✅ No zero-expression genes to remove.")
+
+    # 4. Save Processed File
+    print("\n💾 4. Saving Processed File...")
+    try:
+        adata.write(output_path)
+        print(f"   - ✅ Successfully saved to: {output_path}")
+    except Exception as e:
+        print(f"❌ ERROR: Could not save file. Reason: {e}")
+        return False
+
+    # 5. Final Summary
+    print("\n📋 5. Summary")
+    print("-" * 70)
+    print(f"   - Original shape: {original_shape[0]} cells × {original_shape[1]} genes")
+    print(f"   - Final shape:    {adata.shape[0]} cells × {adata.shape[1]} genes")
+    print("\n   - Issues Found:")
+    if issues_found:
+        for issue in issues_found:
+            print(f"     - {issue}")
+    else:
+        print("     - None")
+    
+    print("\n   - Fixes Applied:")
+    if fixes_applied:
+        for fix in fixes_applied:
+            print(f"     - {fix}")
+    else:
+        print("     - None")
+    
+    print("\n🎉 Preprocessing complete!")
+    return True
+
+def main():
+    if len(sys.argv) != 3:
+        print("Usage: python preprocess_adata.py <input_h5ad_file> <output_h5ad_file>")
+        sys.exit(1)
+    
+    input_path = sys.argv[1]
+    output_path = sys.argv[2]
+    
+    if os.path.abspath(input_path) == os.path.abspath(output_path):
+        print("❌ ERROR: Input and output paths cannot be the same.")
+        sys.exit(1)
+
+    if os.path.exists(output_path):
+        response = input(f"⚠️  Output file already exists: {output_path}\nOverwrite? (y/N): ")
+        if response.lower() != 'y':
+            print("Operation cancelled.")
+            sys.exit(1)
+
+    success = preprocess_adata(input_path, output_path)
+    
+    if not success:
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

transcriptformer_embedding/embedding_store/follicular_lymphoma/b_cell_follicular_lymphoma.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/b_cell_normal.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/cd4_positive_alpha_beta_cytotoxic_t_cell_follicular_lymphoma.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/cd4_positive_alpha_beta_cytotoxic_t_cell_normal.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/cd4_positive_alpha_beta_t_cell_follicular_lymphoma.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/cd4_positive_alpha_beta_t_cell_normal.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/cd8_positive_alpha_beta_t_cell_follicular_lymphoma.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/cd8_positive_alpha_beta_t_cell_normal.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/effector_cd8_positive_alpha_beta_t_cell_follicular_lymphoma.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/effector_cd8_positive_alpha_beta_t_cell_normal.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/erythrocyte_follicular_lymphoma.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/erythrocyte_normal.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/exhausted_t_cell_follicular_lymphoma.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/exhausted_t_cell_normal.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/follicular_dendritic_cell_follicular_lymphoma.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/follicular_dendritic_cell_normal.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/malignant_cell_follicular_lymphoma.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/mature_nk_t_cell_follicular_lymphoma.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/mature_nk_t_cell_normal.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/metadata.json.gz

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/myeloid_cell_follicular_lymphoma.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/myeloid_cell_normal.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/naive_thymus_derived_cd4_positive_alpha_beta_t_cell_follicular_lymphoma.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/naive_thymus_derived_cd4_positive_alpha_beta_t_cell_normal.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/naive_thymus_derived_cd8_positive_alpha_beta_t_cell_follicular_lymphoma.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/naive_thymus_derived_cd8_positive_alpha_beta_t_cell_normal.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/plasma_cell_follicular_lymphoma.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/plasma_cell_normal.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/plasmacytoid_dendritic_cell_follicular_lymphoma.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/plasmacytoid_dendritic_cell_normal.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/regulatory_t_cell_follicular_lymphoma.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/regulatory_t_cell_normal.npy

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

transcriptformer_embedding/embedding_store/follicular_lymphoma/t_cell_follicular_lymphoma.npy

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