SURE-tools 2.2.2__py3-none-any.whl → 2.4.3__py3-none-any.whl

SURE/TranscriptomeDecoder.py

@@ -0,0 +1,527 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torch.nn.functional as F
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+from typing import Dict, List, Tuple, Optional
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+import warnings
+warnings.filterwarnings('ignore')
+
+class TranscriptomeDecoder:
+    def __init__(self, 
+                 latent_dim: int = 100,
+                 gene_dim: int = 60000,
+                 hidden_dim: int = 512,  # Reduced for memory efficiency
+                 device: str = None):
+        """
+        Whole-transcriptome decoder
+        
+        Args:
+            latent_dim: Latent variable dimension (typically 50-100)
+            gene_dim: Number of genes (full transcriptome ~60,000)
+            hidden_dim: Hidden dimension (reduced for memory efficiency)
+            device: Computation device
+        """
+        self.latent_dim = latent_dim
+        self.gene_dim = gene_dim
+        self.hidden_dim = hidden_dim
+        self.device = device or ('cuda' if torch.cuda.is_available() else 'cpu')
+        
+        # Memory optimization settings
+        self.gradient_checkpointing = True
+        self.mixed_precision = True
+        
+        # Initialize model
+        self.model = self._build_model()
+        self.model.to(self.device)
+        
+        # Training state
+        self.is_trained = False
+        self.training_history = None
+        self.best_val_loss = float('inf')
+        
+        print(f"🚀 TranscriptomeDecoder Initialized:")
+        print(f"   - Latent Dimension: {latent_dim}")
+        print(f"   - Gene Dimension: {gene_dim}")
+        print(f"   - Hidden Dimension: {hidden_dim}")
+        print(f"   - Device: {self.device}")
+        print(f"   - Parameters: {sum(p.numel() for p in self.model.parameters()):,}")
+    
+    class MemoryEfficientBlock(nn.Module):
+        """Memory-efficient building block with gradient checkpointing"""
+        def __init__(self, input_dim, output_dim, use_checkpointing=True):
+            super().__init__()
+            self.use_checkpointing = use_checkpointing
+            self.net = nn.Sequential(
+                nn.Linear(input_dim, output_dim),
+                nn.BatchNorm1d(output_dim),
+                nn.GELU(),
+                nn.Dropout(0.1)
+            )
+        
+        def forward(self, x):
+            if self.use_checkpointing and self.training:
+                return torch.utils.checkpoint.checkpoint(self.net, x)
+            return self.net(x)
+    
+    class SparseGeneProjection(nn.Module):
+        """Sparse gene projection to reduce memory usage"""
+        def __init__(self, latent_dim, gene_dim, projection_dim=256):
+            super().__init__()
+            self.projection_dim = projection_dim
+            self.gene_embeddings = nn.Parameter(torch.randn(gene_dim, projection_dim) * 0.02)
+            self.latent_projection = nn.Linear(latent_dim, projection_dim)
+            self.activation = nn.GELU()
+            
+        def forward(self, latent):
+            # Project latent to gene space efficiently
+            batch_size = latent.shape[0]
+            latent_proj = self.latent_projection(latent)  # [batch, projection_dim]
+            
+            # Efficient matrix multiplication
+            gene_embeds = self.gene_embeddings.T  # [projection_dim, gene_dim]
+            output = torch.matmul(latent_proj, gene_embeds)  # [batch, gene_dim]
+            
+            return self.activation(output)
+    
+    class ChunkedTransformer(nn.Module):
+        """Process genes in chunks to reduce memory usage"""
+        def __init__(self, gene_dim, hidden_dim, chunk_size=1000, num_layers=4):
+            super().__init__()
+            self.chunk_size = chunk_size
+            self.num_chunks = (gene_dim + chunk_size - 1) // chunk_size
+            self.layers = nn.ModuleList([
+                nn.Sequential(
+                    nn.Linear(hidden_dim, hidden_dim),
+                    nn.GELU(),
+                    nn.Dropout(0.1),
+                    nn.Linear(hidden_dim, hidden_dim),
+                ) for _ in range(num_layers)
+            ])
+            
+        def forward(self, x):
+            # Process in chunks to save memory
+            batch_size = x.shape[0]
+            output = torch.zeros_like(x)
+            
+            for i in range(self.num_chunks):
+                start_idx = i * self.chunk_size
+                end_idx = min((i + 1) * self.chunk_size, x.shape[1])
+                
+                chunk = x[:, start_idx:end_idx]
+                for layer in self.layers:
+                    chunk = layer(chunk) + chunk  # Residual connection
+                
+                output[:, start_idx:end_idx] = chunk
+            
+            return output
+    
+    class Decoder(nn.Module):
+        """Decoder model"""
+        def __init__(self, latent_dim, gene_dim, hidden_dim):
+            super().__init__()
+            self.latent_dim = latent_dim
+            self.gene_dim = gene_dim
+            self.hidden_dim = hidden_dim
+            
+            # Stage 1: Latent expansion (memory efficient)
+            self.latent_expansion = nn.Sequential(
+                nn.Linear(latent_dim, hidden_dim * 2),
+                nn.GELU(),
+                nn.Dropout(0.1),
+                nn.Linear(hidden_dim * 2, hidden_dim),
+            )
+            
+            # Stage 2: Sparse gene projection
+            self.gene_projection = TranscriptomeDecoder.SparseGeneProjection(
+                latent_dim, gene_dim, hidden_dim
+            )
+            
+            # Stage 3: Chunked processing
+            self.chunked_processor = TranscriptomeDecoder.ChunkedTransformer(
+                gene_dim, hidden_dim, chunk_size=2000, num_layers=3
+            )
+            
+            # Stage 4: Multi-head output with memory efficiency
+            self.output_heads = nn.ModuleList([
+                nn.Sequential(
+                    nn.Linear(hidden_dim, hidden_dim // 2),
+                    nn.GELU(),
+                    nn.Linear(hidden_dim // 2, 1)
+                ) for _ in range(2)  # Reduced from 3 to 2 heads
+            ])
+            
+            # Adaptive fusion
+            self.fusion_gate = nn.Sequential(
+                nn.Linear(hidden_dim, hidden_dim // 4),
+                nn.GELU(),
+                nn.Linear(hidden_dim // 4, len(self.output_heads)),
+                nn.Softmax(dim=-1)
+            )
+            
+            # Output scaling
+            self.output_scale = nn.Parameter(torch.ones(1))
+            self.output_bias = nn.Parameter(torch.zeros(1))
+            
+            self._init_weights()
+        
+        def _init_weights(self):
+            for module in self.modules():
+                if isinstance(module, nn.Linear):
+                    nn.init.xavier_uniform_(module.weight)
+                    if module.bias is not None:
+                        nn.init.zeros_(module.bias)
+        
+        def forward(self, latent):
+            batch_size = latent.shape[0]
+            
+            # 1. Latent expansion
+            latent_expanded = self.latent_expansion(latent)
+            
+            # 2. Gene projection (memory efficient)
+            gene_features = self.gene_projection(latent)
+            
+            # 3. Add latent information
+            print(f'{gene_features.shape}; {latent_expanded.unsqueeze(1).shape}')
+            gene_features = gene_features + latent_expanded.unsqueeze(1)
+            
+            # 4. Chunked processing (memory efficient)
+            gene_features = self.chunked_processor(gene_features)
+            
+            # 5. Multi-head output with chunking
+            final_output = torch.zeros(batch_size, self.gene_dim, device=latent.device)
+            
+            # Process output in chunks
+            chunk_size = 5000
+            for i in range(0, self.gene_dim, chunk_size):
+                end_idx = min(i + chunk_size, self.gene_dim)
+                chunk = gene_features[:, i:end_idx]
+                
+                head_outputs = []
+                for head in self.output_heads:
+                    head_out = head(chunk).squeeze(-1)
+                    head_outputs.append(head_out)
+                
+                # Adaptive fusion
+                gate_weights = self.fusion_gate(chunk.mean(dim=1, keepdim=True))
+                gate_weights = gate_weights.unsqueeze(1)
+                
+                # Weighted fusion
+                chunk_output = torch.zeros_like(head_outputs[0])
+                for j, head_out in enumerate(head_outputs):
+                    chunk_output = chunk_output + gate_weights[:, :, j] * head_out
+                
+                final_output[:, i:end_idx] = chunk_output
+            
+            # Final activation
+            final_output = F.softplus(final_output * self.output_scale + self.output_bias)
+            
+            return final_output
+    
+    def _build_model(self):
+        """Build model"""
+        return self.Decoder(self.latent_dim, self.gene_dim, self.hidden_dim)
+    
+    def train(self,
+              train_latent: np.ndarray,
+              train_expression: np.ndarray,
+              val_latent: np.ndarray = None,
+              val_expression: np.ndarray = None,
+              batch_size: int = 16,  # Reduced batch size for memory
+              num_epochs: int = 100,
+              learning_rate: float = 1e-4,
+              checkpoint_path: str = 'transcriptome_decoder.pth'):
+        """
+        Memory-efficient training with optimizations
+        
+        Args:
+            train_latent: Training latent variables
+            train_expression: Training expression data
+            val_latent: Validation latent variables
+            val_expression: Validation expression data
+            batch_size: Reduced batch size for memory constraints
+            num_epochs: Number of training epochs
+            learning_rate: Learning rate
+            checkpoint_path: Model save path
+        """
+        print("🚀 Starting Training...")
+        print(f"📊 Batch size: {batch_size}")
+        
+        # Enable memory optimizations
+        torch.backends.cudnn.benchmark = True
+        if self.mixed_precision:
+            scaler = torch.cuda.amp.GradScaler()
+        
+        # Data preparation
+        train_dataset = self._create_dataset(train_latent, train_expression)
+        
+        if val_latent is not None and val_expression is not None:
+            val_dataset = self._create_dataset(val_latent, val_expression)
+        else:
+            # Auto split
+            train_size = int(0.9 * len(train_dataset))
+            val_size = len(train_dataset) - train_size
+            train_dataset, val_dataset = torch.utils.data.random_split(
+                train_dataset, [train_size, val_size]
+            )
+        
+        train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, 
+                                 pin_memory=True, num_workers=2)
+        val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False,
+                               pin_memory=True, num_workers=2)
+        
+        # Optimizer with memory-friendly settings
+        optimizer = optim.AdamW(
+            self.model.parameters(),
+            lr=learning_rate,
+            weight_decay=0.01,
+            betas=(0.9, 0.999)
+        )
+        
+        # Learning rate scheduler
+        scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=num_epochs)
+        
+        # Loss function
+        criterion = nn.MSELoss()
+        
+        # Training history
+        history = {
+            'train_loss': [], 'val_loss': [],
+            'learning_rate': [], 'memory_usage': []
+        }
+        
+        best_val_loss = float('inf')
+        
+        for epoch in range(1, num_epochs + 1):
+            print(f"\n📍 Epoch {epoch}/{num_epochs}")
+            
+            # Training phase with memory monitoring
+            train_loss = self._train_epoch(
+                train_loader, optimizer, criterion, scaler if self.mixed_precision else None
+            )
+            
+            # Validation phase
+            val_loss = self._validate_epoch(val_loader, criterion)
+            
+            # Update scheduler
+            scheduler.step()
+            
+            # Record history
+            history['train_loss'].append(train_loss)
+            history['val_loss'].append(val_loss)
+            history['learning_rate'].append(optimizer.param_groups[0]['lr'])
+            
+            # Memory usage tracking
+            if torch.cuda.is_available():
+                memory_used = torch.cuda.memory_allocated() / 1024**3  # GB
+                history['memory_usage'].append(memory_used)
+                print(f"💾 GPU Memory: {memory_used:.1f}GB / 20GB")
+            
+            print(f"📊 Train Loss: {train_loss:.4f} | Val Loss: {val_loss:.4f}")
+            print(f"⚡ Learning Rate: {optimizer.param_groups[0]['lr']:.2e}")
+            
+            # Save best model
+            if val_loss < best_val_loss:
+                best_val_loss = val_loss
+                self._save_checkpoint(epoch, optimizer, scheduler, best_val_loss, history, checkpoint_path)
+                print("💾 Best model saved!")
+        
+        self.is_trained = True
+        self.training_history = history
+        self.best_val_loss = best_val_loss
+        
+        print(f"\n🎉 Training completed! Best validation loss: {best_val_loss:.4f}")
+        return history
+    
+    def _train_epoch(self, train_loader, optimizer, criterion, scaler=None):
+        """Training epoch"""
+        self.model.train()
+        total_loss = 0
+        
+        pbar = tqdm(train_loader, desc='Training')
+        for latent, target in pbar:
+            latent = latent.to(self.device, non_blocking=True)
+            target = target.to(self.device, non_blocking=True)
+            
+            optimizer.zero_grad(set_to_none=True)  # Memory optimization
+            
+            if scaler:  # Mixed precision training
+                with torch.cuda.amp.autocast():
+                    pred = self.model(latent)
+                    loss = criterion(pred, target)
+                
+                scaler.scale(loss).backward()
+                scaler.step(optimizer)
+                scaler.update()
+            else:
+                pred = self.model(latent)
+                loss = criterion(pred, target)
+                loss.backward()
+                optimizer.step()
+            
+            total_loss += loss.item()
+            pbar.set_postfix({'Loss': f'{loss.item():.4f}'})
+            
+            # Clear memory
+            del pred, loss
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+        
+        return total_loss / len(train_loader)
+    
+    def _validate_epoch(self, val_loader, criterion):
+        """Validation"""
+        self.model.eval()
+        total_loss = 0
+        
+        with torch.no_grad():
+            for latent, target in val_loader:
+                latent = latent.to(self.device, non_blocking=True)
+                target = target.to(self.device, non_blocking=True)
+                
+                pred = self.model(latent)
+                loss = criterion(pred, target)
+                total_loss += loss.item()
+                
+                # Clear memory
+                del pred, loss
+        
+        return total_loss / len(val_loader)
+    
+    def _create_dataset(self, latent_data, expression_data):
+        """Create dataset"""
+        class EfficientDataset(Dataset):
+            def __init__(self, latent, expression):
+                self.latent = torch.FloatTensor(latent)
+                self.expression = torch.FloatTensor(expression)
+            
+            def __len__(self):
+                return len(self.latent)
+            
+            def __getitem__(self, idx):
+                return self.latent[idx], self.expression[idx]
+        
+        return EfficientDataset(latent_data, expression_data)
+    
+    def _save_checkpoint(self, epoch, optimizer, scheduler, best_loss, history, path):
+        """Save checkpoint"""
+        torch.save({
+            'epoch': epoch,
+            'model_state_dict': self.model.state_dict(),
+            'optimizer_state_dict': optimizer.state_dict(),
+            'scheduler_state_dict': scheduler.state_dict(),
+            'best_val_loss': best_loss,
+            'training_history': history,
+            'model_config': {
+                'latent_dim': self.latent_dim,
+                'gene_dim': self.gene_dim,
+                'hidden_dim': self.hidden_dim
+            }
+        }, path)
+    
+    def predict(self, latent_data: np.ndarray, batch_size: int = 8) -> np.ndarray:
+        """
+        Prediction
+        
+        Args:
+            latent_data: Latent variables [n_samples, latent_dim]
+            batch_size: Prediction batch size for memory control
+        
+        Returns:
+            expression: Predicted expression [n_samples, gene_dim]
+        """
+        if not self.is_trained:
+            warnings.warn("Model not trained. Predictions may be inaccurate.")
+        
+        self.model.eval()
+        
+        if isinstance(latent_data, np.ndarray):
+            latent_data = torch.FloatTensor(latent_data)
+        
+        # Predict in batches to save memory
+        predictions = []
+        with torch.no_grad():
+            for i in range(0, len(latent_data), batch_size):
+                batch_latent = latent_data[i:i+batch_size].to(self.device)
+                batch_pred = self.model(batch_latent)
+                predictions.append(batch_pred.cpu())
+                
+                # Clear memory
+                del batch_pred
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+        
+        return torch.cat(predictions).numpy()
+    
+    def load_model(self, model_path: str):
+        """Load pre-trained model"""
+        checkpoint = torch.load(model_path, map_location=self.device)
+        self.model.load_state_dict(checkpoint['model_state_dict'])
+        self.is_trained = True
+        self.training_history = checkpoint.get('training_history')
+        self.best_val_loss = checkpoint.get('best_val_loss', float('inf'))
+        print(f"✅ Model loaded! Best validation loss: {self.best_val_loss:.4f}")
+    
+    def get_memory_info(self) -> Dict:
+        """Get memory usage information"""
+        if torch.cuda.is_available():
+            memory_allocated = torch.cuda.memory_allocated() / 1024**3
+            memory_reserved = torch.cuda.memory_reserved() / 1024**3
+            return {
+                'allocated_gb': memory_allocated,
+                'reserved_gb': memory_reserved,
+                'available_gb': 20 - memory_allocated,
+                'utilization_percent': (memory_allocated / 20) * 100
+            }
+        return {'available_gb': 'N/A (CPU mode)'}
+    
+'''
+# Example usage with memory monitoring
+def example_usage():
+    """Memory-efficient example"""
+    
+    # 1. Initialize memory-efficient decoder
+    decoder = TranscriptomeDecoder(
+        latent_dim=100,
+        gene_dim=2000,  # Reduced for example
+        hidden_dim=256   # Reduced for memory
+    )
+    
+    # Check memory info
+    memory_info = decoder.get_memory_info()
+    print(f"📊 Memory Info: {memory_info}")
+    
+    # 2. Generate example data
+    n_samples = 500  # Reduced for memory
+    latent_data = np.random.randn(n_samples, 100).astype(np.float32)
+    expression_data = np.random.randn(n_samples, 2000).astype(np.float32)
+    expression_data = np.maximum(expression_data, 0)  # Non-negative
+    
+    print(f"📈 Data shapes: Latent {latent_data.shape}, Expression {expression_data.shape}")
+    
+    # 3. Train with memory monitoring
+    history = decoder.train(
+        train_latent=latent_data,
+        train_expression=expression_data,
+        batch_size=8,  # Small batch for memory
+        num_epochs=20   # Reduced for example
+    )
+    
+    # 4. Memory-efficient prediction
+    test_latent = np.random.randn(5, 100).astype(np.float32)
+    predictions = decoder.predict(test_latent, batch_size=2)
+    print(f"🔮 Prediction shape: {predictions.shape}")
+    
+    # 5. Final memory check
+    final_memory = decoder.get_memory_info()
+    print(f"💾 Final memory usage: {final_memory}")
+    
+    return decoder
+
+if __name__ == "__main__":
+    example_usage()
+    
+'''

SURE/__init__.py

@@ -1,5 +1,7 @@
 from .SURE import SURE
 from .DensityFlow import DensityFlow
+from .PerturbE import PerturbE
+from .TranscriptomeDecoder import TranscriptomeDecoder
 
 from . import utils 
 from . import codebook
@@ -8,5 +10,7 @@ from . import DensityFlow
 from . import atac
 from . import flow 
 from . import perturb
+from . import PerturbE
+from . import TranscriptomeDecoder
 
-__all__ = ['SURE', 'DensityFlow', 'flow', 'perturb', 'atac', 'utils', 'codebook']
+__all__ = ['SURE', 'DensityFlow', 'PerturbE', 'TranscriptomeDecoder', 'flow', 'perturb', 'atac', 'utils', 'codebook']

SURE/perturb/perturb.py

@@ -1,5 +1,6 @@
 import re
 import numpy as np
+import pandas as pd
 from numba import njit
 from itertools import chain
 from joblib import Parallel, delayed
@@ -8,6 +9,8 @@ from typing import Literal
 class LabelMatrix:
     def __init__(self):
         self.labels_ = None
+        self.control_label = None 
+        self.sep_pattern = None
     
     def fit_transform(self, labels, control_label=None, sep_pattern=r'[,;_\s]', speedup: Literal['none','vectorize','parallel']='none'):
         if speedup=='none':
@@ -24,8 +27,31 @@ class LabelMatrix:
             mat = np.delete(mat, idx, axis=1)
             self.labels_ = np.delete(self.labels_, idx)
             
+        self.control_label = control_label
+        self.sep_pattern=sep_pattern
+        
         return mat
-            
+    
+    def transform(self, labels, speedup: Literal['none','vectorize','parallel']='none'):
+        sep_pattern = self.sep_pattern
+        if speedup=='none':
+            mat, labels_ = label_to_matrix(labels=labels, sep_pattern=sep_pattern)
+        elif speedup=='vectorize':
+            mat, labels_ = vectorized_label_to_matrix(labels=labels, sep_pattern=sep_pattern)
+        elif speedup=='parallel':
+            mat, labels_ = parallel_label_to_matrix(labels=labels, sep_pattern=sep_pattern)
+          
+        mat_df = pd.DataFrame(mat, columns=labels_)
+        
+        labels_valid = [x for x in labels_ if x in self.labels_]  
+        mat_df = mat_df[labels_valid]
+        
+        mat_valid = np.zeros([mat.shape[0], len(self.labels_)])
+        mat_valid_df = pd.DataFrame(mat_valid, columns=self.labels_)
+        mat_valid_df[labels_valid] = mat_df 
+        
+        return mat_valid_df.values
+        
     def inverse_transform(self, matrix):
         return matrix_to_labels(matrix=matrix, unique_labels=self.labels_)
 

SURE/utils/custom_mlp.py

@@ -240,12 +240,49 @@ class ZeroBiasMLP(nn.Module):
         y = self.mlp(x)
         mask = torch.zeros_like(y)
         if len(y.shape)==2:
-            mask[x[1][:,0]>0,:] = 1
+            if type(x)==list:
+                mask[x[1][:,0]>0,:] = 1
+            else:
+                mask[x[:,0]>0,:] = 1
         elif len(y.shape)==3:
-            mask[:,x[1][:,0]>0,:] = 1
+            if type(x)==list:
+                mask[:,x[1][:,0]>0,:] = 1
+            else:
+                mask[:,x[:,0]>0,:] = 1
         return y*mask
         
 
+
+class ZeroBiasMLP2(nn.Module):
+    def __init__(
+        self,
+        mlp_sizes,
+        activation=nn.ReLU,
+        output_activation=None,
+        post_layer_fct=lambda layer_ix, total_layers, layer: None,
+        post_act_fct=lambda layer_ix, total_layers, layer: None,
+        allow_broadcast=False,
+        use_cuda=False,
+    ):
+        # init the module object
+        super().__init__()
+        self.mlp = MLP(mlp_sizes=mlp_sizes,
+                       activation=activation,
+                       output_activation=output_activation,
+                       post_layer_fct=post_layer_fct,
+                       post_act_fct=post_act_fct,
+                       allow_broadcast=allow_broadcast,
+                       use_cuda=use_cuda,
+                       bias=True)
+        
+    # pass through our sequential for the output!
+    def forward(self, x):
+        y = self.mlp(x)
+        mask = torch.zeros_like(y)
+        x_sum = torch.sum(x, dim=1)
+        mask[x_sum>0,:] = 1
+        return y*mask
+    
 class HDMLP(nn.Module):
     def __init__(
         self,

{sure_tools-2.2.2.dist-info → sure_tools-2.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SURE-tools
-Version: 2.2.2
+Version: 2.4.3
 Summary: Succinct Representation of Single Cells
 Home-page: https://github.com/ZengFLab/SURE
 Author: Feng Zeng

{sure_tools-2.2.2.dist-info → sure_tools-2.4.3.dist-info}/RECORD

@@ -1,7 +1,8 @@
-SURE/DensityFlow.py,sha256=ACSFkwzlyBqLH39SSOKKepaVFXldpX0Hbu50jd9jjXQ,54676
-SURE/PerturbFlow.py,sha256=kVpEdVgW_AGvvv7d1KnnBydx_hGfpXUXmFg4t4dPlwY,54677
+SURE/DensityFlow.py,sha256=YvaE9aPbAC2U7WhTye5i2AMtcw0BI_qS3gv9SP4aE0k,56676
+SURE/PerturbE.py,sha256=DxEp-qef--x8-GMZdPfBf8ts8UDDc34h2P5AnpqZ-YM,52265
 SURE/SURE.py,sha256=MXs7iuvcj-lU4dJ_MwKegpL2Rqk2HB4eFfAgHRA3RtA,47744
-SURE/__init__.py,sha256=NVp22RCHrhSwHNMomABC-eftoCYvt7vV1XOzim-UZHE,293
+SURE/TranscriptomeDecoder.py,sha256=4Ai0AeXnEwgUHB-gDsS9v3pHWFkawnTCzdidSRlXlnk,20337
+SURE/__init__.py,sha256=pNSGQ4BMqMXBAPHpFOYNB8_0vFW-RqPy3rr5fvdEEyU,473
 SURE/assembly/__init__.py,sha256=jxZLURXKPzXe21LhrZ09LgZr33iqdjlQy4oSEj5gR2Q,172
 SURE/assembly/assembly.py,sha256=6IMdelPOiRO4mUb4dC7gVCoF1Uvfw86-Map8P_jnUag,21477
 SURE/assembly/atlas.py,sha256=ALjmVWutm_tOHTcT1aqOxmuCEQw-XzrtDoMCV_8oXLk,21794
@@ -13,14 +14,14 @@ SURE/flow/__init__.py,sha256=rsAjYsh1xVIrxBCuwOE0Q_6N5th1wBgjJceV0ABPG3c,183
 SURE/flow/flow_stats.py,sha256=6SzNMT59WRFRP1nC6bvpBPF7BugWnkIS_DSlr4S-Ez0,11338
 SURE/flow/plot_quiver.py,sha256=UbmuScUcgbQHeMmjKmgqxjrIjHhiHx0VWct16UMMwuE,8110
 SURE/perturb/__init__.py,sha256=8TP1dSUhXiZzKpFebHZmm8XMMGbUz_OfQ10xu-6uPPY,43
-SURE/perturb/perturb.py,sha256=1iSsCePcwkA2CyM1nCdq_G8gogUNjhMH0BfhhvhpJQk,5037
+SURE/perturb/perturb.py,sha256=ey7cxsM1tO1MW4UaE_MLpLHK87CjvXzn2CBPtvv1VZ0,6116
 SURE/utils/__init__.py,sha256=YF5jB-PAHJQ40OlcZ7BCZbsN2q1JKuPT6EppilRXQqM,680
-SURE/utils/custom_mlp.py,sha256=HuNb7f8-6RFjsvfEu1XOuNpLrHZkGYHgf8TpJfPSNO0,9382
+SURE/utils/custom_mlp.py,sha256=Rn_PQouxPMSda-KKBYrwVVv3GFFuUmCLxp8cV5LszZo,10580
 SURE/utils/queue.py,sha256=E_5PA5EWcBoGAZj8BkKQnkCK0p4C-4-xcTPqdIXaPXU,1892
 SURE/utils/utils.py,sha256=IUHjDDtYaAYllCWsZyIzqQwaLul6fJRvHRH4vIYcR-c,8462
-sure_tools-2.2.2.dist-info/licenses/LICENSE,sha256=TFHKwmrAViXQbSX5W-NDItkWFjm45HWOeUniDrqmnu0,1065
-sure_tools-2.2.2.dist-info/METADATA,sha256=ptLGAXYWNil97QNNpcCCasW3pWTNe6kMRYm-vTm6TBE,2677
-sure_tools-2.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sure_tools-2.2.2.dist-info/entry_points.txt,sha256=-nJI8rVe_qqrR0HmfAODzj-JNfEqCcSsyVh6okSqyHk,83
-sure_tools-2.2.2.dist-info/top_level.txt,sha256=BtFTebdiJeqra4r6mm-uEtwVRFLZ_IjYsQ7OnalrOvY,5
-sure_tools-2.2.2.dist-info/RECORD,,
+sure_tools-2.4.3.dist-info/licenses/LICENSE,sha256=TFHKwmrAViXQbSX5W-NDItkWFjm45HWOeUniDrqmnu0,1065
+sure_tools-2.4.3.dist-info/METADATA,sha256=GX1UIc4xRMWryqUkvvF9xbtTSke6nIpFhUrHT8IMagU,2677
+sure_tools-2.4.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sure_tools-2.4.3.dist-info/entry_points.txt,sha256=-nJI8rVe_qqrR0HmfAODzj-JNfEqCcSsyVh6okSqyHk,83
+sure_tools-2.4.3.dist-info/top_level.txt,sha256=BtFTebdiJeqra4r6mm-uEtwVRFLZ_IjYsQ7OnalrOvY,5
+sure_tools-2.4.3.dist-info/RECORD,,