SURE-tools 2.2.4__tar.gz → 2.2.10__tar.gz

{sure_tools-2.2.4 → sure_tools-2.2.10}/PKG-INFO

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

{sure_tools-2.2.4 → sure_tools-2.2.10}/SURE/DensityFlow.py

@@ -62,7 +62,7 @@ class DensityFlow(nn.Module):
                  supervised_mode: bool = False,
                  z_dim: int = 10,
                  z_dist: Literal['normal','studentt','laplacian','cauchy','gumbel'] = 'gumbel',
-                 loss_func: Literal['negbinomial','poisson','multinomial','bernoulli'] = 'poisson',
+                 loss_func: Literal['negbinomial','poisson','multinomial','bernoulli'] = 'negbinomial',
                  inverse_dispersion: float = 10.0,
                  use_zeroinflate: bool = True,
                  hidden_layers: list = [500],
@@ -234,6 +234,16 @@ class DensityFlow(nn.Module):
                     allow_broadcast=self.allow_broadcast,
                     use_cuda=self.use_cuda,
                 )
+        if self.loss_func == 'negbinomial':
+            self.decoder_total_count = MLP(
+                    [self.latent_dim] + self.decoder_hidden_layers + [self.input_size],
+                    activation=activate_fct,
+                    output_activation=Exp,
+                    post_layer_fct=post_layer_fct,
+                    post_act_fct=post_act_fct,
+                    allow_broadcast=self.allow_broadcast,
+                    use_cuda=self.use_cuda,
+                )
 
         if self.latent_dist == 'studentt':
             self.codebook = MLP(
@@ -314,9 +324,9 @@ class DensityFlow(nn.Module):
         batch_size = xs.size(0)
         self.options = dict(dtype=xs.dtype, device=xs.device)
         
-        if self.loss_func=='negbinomial':
-            total_count = pyro.param("inverse_dispersion", self.inverse_dispersion *
-                                     xs.new_ones(self.input_size), constraint=constraints.positive)
+        #if self.loss_func=='negbinomial':
+        #    total_count = pyro.param("inverse_dispersion", self.inverse_dispersion *
+        #                             xs.new_ones(self.input_size), constraint=constraints.positive)
             
         if self.use_zeroinflate:
             gate_logits = pyro.param("dropout_rate", xs.new_zeros(self.input_size))
@@ -360,6 +370,7 @@ class DensityFlow(nn.Module):
                     rate = theta * torch.sum(xs, dim=1, keepdim=True)
 
             if self.loss_func == 'negbinomial':
+                total_count = self.decoder_total_count(zs)
                 if self.use_zeroinflate:
                     pyro.sample('x', dist.ZeroInflatedDistribution(dist.NegativeBinomial(total_count=total_count, probs=theta),gate_logits=gate_logits).to_event(1), obs=xs)
                 else:
@@ -393,9 +404,9 @@ class DensityFlow(nn.Module):
         batch_size = xs.size(0)
         self.options = dict(dtype=xs.dtype, device=xs.device)
         
-        if self.loss_func=='negbinomial':
-            total_count = pyro.param("inverse_dispersion", self.inverse_dispersion *
-                                     xs.new_ones(self.input_size), constraint=constraints.positive)
+        #if self.loss_func=='negbinomial':
+        #    total_count = pyro.param("inverse_dispersion", self.inverse_dispersion *
+        #                             xs.new_ones(self.input_size), constraint=constraints.positive)
             
         if self.use_zeroinflate:
             gate_logits = pyro.param("dropout_rate", xs.new_zeros(self.input_size))
@@ -444,6 +455,7 @@ class DensityFlow(nn.Module):
                     rate = theta * torch.sum(xs, dim=1, keepdim=True)
 
             if self.loss_func == 'negbinomial':
+                total_count = self.decoder_total_count(zs)
                 if self.use_zeroinflate:
                     pyro.sample('x', dist.ZeroInflatedDistribution(dist.NegativeBinomial(total_count=total_count, probs=theta),gate_logits=gate_logits).to_event(1), obs=xs)
                 else:
@@ -477,9 +489,9 @@ class DensityFlow(nn.Module):
         batch_size = xs.size(0)
         self.options = dict(dtype=xs.dtype, device=xs.device)
         
-        if self.loss_func=='negbinomial':
-            total_count = pyro.param("inverse_dispersion", self.inverse_dispersion *
-                                     xs.new_ones(self.input_size), constraint=constraints.positive)
+        #if self.loss_func=='negbinomial':
+        #    total_count = pyro.param("inverse_dispersion", self.inverse_dispersion *
+        #                             xs.new_ones(self.input_size), constraint=constraints.positive)
             
         if self.use_zeroinflate:
             gate_logits = pyro.param("dropout_rate", xs.new_zeros(self.input_size))
@@ -540,6 +552,7 @@ class DensityFlow(nn.Module):
                     rate = theta * torch.sum(xs, dim=1, keepdim=True)
 
             if self.loss_func == 'negbinomial':
+                total_count = self.decoder_total_count(zs)
                 if self.use_zeroinflate:
                     pyro.sample('x', dist.ZeroInflatedDistribution(dist.NegativeBinomial(total_count=total_count, probs=theta),gate_logits=gate_logits).to_event(1), obs=xs)
                 else:
@@ -573,9 +586,9 @@ class DensityFlow(nn.Module):
         batch_size = xs.size(0)
         self.options = dict(dtype=xs.dtype, device=xs.device)
         
-        if self.loss_func=='negbinomial':
-            total_count = pyro.param("inverse_dispersion", self.inverse_dispersion *
-                                     xs.new_ones(self.input_size), constraint=constraints.positive)
+        #if self.loss_func=='negbinomial':
+        #    total_count = pyro.param("inverse_dispersion", self.inverse_dispersion *
+        #                             xs.new_ones(self.input_size), constraint=constraints.positive)
             
         if self.use_zeroinflate:
             gate_logits = pyro.param("dropout_rate", xs.new_zeros(self.input_size))
@@ -646,6 +659,7 @@ class DensityFlow(nn.Module):
                     rate = theta * torch.sum(xs, dim=1, keepdim=True)
 
             if self.loss_func == 'negbinomial':
+                total_count = self.decoder_total_count(zs)
                 if self.use_zeroinflate:
                     pyro.sample('x', dist.ZeroInflatedDistribution(dist.NegativeBinomial(total_count=total_count, probs=theta),gate_logits=gate_logits).to_event(1), obs=xs)
                 else:
@@ -824,9 +838,11 @@ class DensityFlow(nn.Module):
             
             # perturbation effect 
             ps = np.ones_like(us_i)
-            dzs = self.get_cell_response(xs, factor_idx=pert_idx, perturb=ps)
-            
-            zs = zs + dzs0 + dzs
+            if np.sum(np.abs(ps-us_i))>=1:
+                dzs = self.get_cell_response(xs, factor_idx=pert_idx, perturb=ps)          
+                zs = zs + dzs0 + dzs
+            else:
+                zs = zs + dzs0
         
         if library_sizes is None:
             library_sizes = np.sum(xs, axis=1, keepdims=True)
@@ -905,33 +921,18 @@ class DensityFlow(nn.Module):
         R = np.concatenate(R)
         return R
     
-    def _count(self,concentrate, library_size=None):
+    def _count(self, concentrate, library_size=None):
         if self.loss_func == 'bernoulli':
             #counts = self.sigmoid(concentrate)
             counts = dist.Bernoulli(logits=concentrate).to_event(1).mean
         else:
             rate = concentrate.exp()
             theta = dist.DirichletMultinomial(total_count=1, concentration=rate).mean
-            if self.loss_func in ['poisson','multinomial']:
-                rate = theta * library_size
-                counts = dist.Poisson(rate=rate).to_event(1).mean
-            elif self.loss_func == 'negbinomial':
-                total_count = self.inverse_dispersion
-                counts = dist.NegativeBinomial(total_count=total_count, probs=theta).to_event(1).mean                
-        return counts
-    
-    def _count_sample(self,concentrate):
-        if self.loss_func == 'bernoulli':
-            logits = concentrate
-            counts = dist.Bernoulli(logits=logits).to_event(1).sample()
-        else:
-            counts = self._count(concentrate=concentrate)
-            counts = dist.Poisson(rate=counts).to_event(1).sample()
+            counts = theta * library_size
         return counts
     
     def get_counts(self, zs, library_sizes,
-                        batch_size: int = 1024, 
-                        use_sampler: bool = False):
+                        batch_size: int = 1024):
 
         zs = convert_to_tensor(zs, device=self.get_device())
         
@@ -948,10 +949,7 @@ class DensityFlow(nn.Module):
         with tqdm(total=len(dataloader), desc='', unit='batch') as pbar:
             for Z_batch, L_batch, _ in dataloader:
                 concentrate = self._get_expression_response(Z_batch)
-                if use_sampler:
-                    counts = self._count_sample(concentrate)
-                else:
-                    counts = self._count(concentrate, L_batch)
+                counts = self._count(concentrate, L_batch)
                 E.append(tensor_to_numpy(counts))
                 pbar.update(1)
         
@@ -1096,9 +1094,6 @@ class DensityFlow(nn.Module):
                 # Update progress bar
                 pbar.set_postfix({'loss': str_loss})
                 pbar.update(1)
-        
-        if self.loss_func == 'negbinomial':
-            self.inverse_dispersion = pyro.param("inverse_dispersion")
                 
     @classmethod
     def save_model(cls, model, file_path, compression=False):

{sure_tools-2.2.4 → sure_tools-2.2.10}/SURE_tools.egg-info/PKG-INFO

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

{sure_tools-2.2.4 → sure_tools-2.2.10}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name='SURE-tools',
-    version='2.2.4',
+    version='2.2.10',
     description='Succinct Representation of Single Cells',
     long_description=long_description,
     long_description_content_type="text/markdown",