flaxdiff 0.1.37.2__tar.gz → 0.1.37.4__tar.gz

{flaxdiff-0.1.37.2 → flaxdiff-0.1.37.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flaxdiff
-Version: 0.1.37.2
+Version: 0.1.37.4
 Summary: A versatile and easy to understand Diffusion library
 Author-email: Ashish Kumar Singh <ashishkmr472@gmail.com>
 License-Expression: MIT

{flaxdiff-0.1.37.2 → flaxdiff-0.1.37.4}/flaxdiff/predictors/__init__.py

@@ -81,16 +81,16 @@ class KarrasPredictionTransform(DiffusionPredictionTransform):
         epsilon = (x_t - x_0 * signal_rate) / noise_rate
         return x_0, epsilon
     
-    def pred_transform(self, x_t, preds, rates: tuple[jnp.ndarray, jnp.ndarray]) -> jnp.ndarray:
+    def pred_transform(self, x_t, preds, rates: tuple[jnp.ndarray, jnp.ndarray], epsilon=1e-8) -> jnp.ndarray:
         _, sigma = rates
-        c_out = sigma * self.sigma_data / jnp.sqrt(self.sigma_data ** 2 + sigma ** 2)
-        c_skip = self.sigma_data ** 2 / (self.sigma_data ** 2 + sigma ** 2)
+        c_out = sigma * self.sigma_data / (jnp.sqrt(self.sigma_data ** 2 + sigma ** 2) + epsilon)
+        c_skip = self.sigma_data ** 2 / (self.sigma_data ** 2 + sigma ** 2 + epsilon)
         c_out = c_out.reshape((-1, 1, 1, 1))
         c_skip = c_skip.reshape((-1, 1, 1, 1))
         x_0 = c_out * preds + c_skip * x_t
         return x_0
     
-    def get_input_scale(self, rates: tuple[jnp.ndarray, jnp.ndarray]) -> jnp.ndarray:
+    def get_input_scale(self, rates: tuple[jnp.ndarray, jnp.ndarray], epsilon=1e-8) -> jnp.ndarray:
         _, sigma = rates
-        c_in = 1 / jnp.sqrt(self.sigma_data ** 2 + sigma ** 2)
+        c_in = 1 / (jnp.sqrt(self.sigma_data ** 2 + sigma ** 2) + epsilon)
         return c_in

{flaxdiff-0.1.37.2 → flaxdiff-0.1.37.4}/flaxdiff/samplers/common.py

@@ -2,20 +2,15 @@ from flax import linen as nn
 import jax
 import jax.numpy as jnp
 import tqdm
-from typing import Union
+from typing import Union, Type
 from ..schedulers import NoiseScheduler
 from ..utils import RandomMarkovState, MarkovState, clip_images
 from ..predictors import DiffusionPredictionTransform, EpsilonPredictionTransform
 
 class DiffusionSampler():
-    model:nn.Module
-    noise_schedule:NoiseScheduler
-    params:dict
-    model_output_transform:DiffusionPredictionTransform
-
     def __init__(self, model:nn.Module, params:dict,  
                  noise_schedule:NoiseScheduler, 
-                 model_output_transform:DiffusionPredictionTransform=EpsilonPredictionTransform(),
+                 model_output_transform:DiffusionPredictionTransform,
                  guidance_scale:float = 0.0,
                  null_labels_seq:jax.Array=None,
                  autoencoder=None,
@@ -122,9 +117,11 @@ class DiffusionSampler():
                         end_step:int = 0,
                         steps_override=None,
                         priors=None, 
-                        rngstate:RandomMarkovState=RandomMarkovState(jax.random.PRNGKey(42)),
+                        rngstate:RandomMarkovState=None,
                         model_conditioning_inputs:tuple=()
                         ) -> jnp.ndarray:
+        if rngstate is None:
+            rngstate = RandomMarkovState(jax.random.PRNGKey(42))
         if priors is None:
             rngstate, newrngs = rngstate.get_random_key()
             samples = self.get_initial_samples(num_images, newrngs, start_step)
@@ -169,4 +166,5 @@ class DiffusionSampler():
         if self.autoencoder is not None:
             samples = self.autoencoder.decode(samples)
         samples = clip_images(samples)
-        return samples
+        return samples
+    

{flaxdiff-0.1.37.2 → flaxdiff-0.1.37.4}/flaxdiff/trainer/diffusion_trainer.py

@@ -167,7 +167,10 @@ class DiffusionTrainer(SimpleTrainer):
             noise_level, local_rng_state = noise_schedule.generate_timesteps(images.shape[0], local_rng_state)
             
             local_rng_state, rngs = local_rng_state.get_random_key()
-            noise: jax.Array = jax.random.normal(rngs, shape=images.shape)
+            noise: jax.Array = jax.random.normal(rngs, shape=images.shape, dtype=jnp.float32)
+            
+            # Make sure image is also float32
+            images = images.astype(jnp.float32)
             
             rates = noise_schedule.get_rates(noise_level)
             noisy_images, c_in, expected_output = model_output_transform.forward_diffusion(
@@ -197,8 +200,23 @@ class DiffusionTrainer(SimpleTrainer):
                 loss, grads = grad_fn(train_state.params)
                 if distributed_training:
                     grads = jax.lax.pmean(grads, "data")
+                    
+            # # check gradients for NaN/Inf
+            # has_nan_or_inf = jax.tree_util.tree_reduce(
+            #     lambda acc, x: jnp.logical_or(acc, jnp.logical_or(jnp.isnan(x).any(), jnp.isinf(x).any())),
+            #     grads,
+            #     initializer=False
+            # )
             
-            new_state = train_state.apply_gradients(grads=grads)
+            # # Only apply gradients if they're valid
+            # new_state = jax.lax.cond(
+            #     has_nan_or_inf,
+            #     lambda _: train_state,  # Skip gradient update
+            #     lambda _: train_state.apply_gradients(grads=grads),
+            #     operand=None
+            # )
+    
+            # new_state = train_state.apply_gradients(grads=grads)
             
             if train_state.dynamic_scale is not None:
                 # if is_fin == False the gradients contain Inf/NaNs and optimizer state and

{flaxdiff-0.1.37.2 → flaxdiff-0.1.37.4}/flaxdiff/trainer/simple_trainer.py

@@ -403,7 +403,6 @@ class SimpleTrainer:
         rng_state
     ):
         global_device_count = jax.device_count()
-        local_device_count = jax.local_device_count()
         process_index = jax.process_index()
         if self.distributed_training:
             global_device_indexes = jnp.arange(global_device_count)
@@ -434,11 +433,16 @@ class SimpleTrainer:
                 # loss = jax.experimental.multihost_utils.process_allgather(loss)
                 loss = jnp.mean(loss) # Just to make sure its a scaler value
                     
-            if loss <= 1e-6:
+            if loss <= 1e-8:
                 # If the loss is too low, we can assume the model has diverged
                 print(colored(f"Loss too low at step {current_step} => {loss}", 'red'))
                 # Reset the model to the old state
-                exit(1)
+                if self.best_state is not None:
+                    print(colored(f"Resetting model to best state", 'red'))
+                    train_state = self.best_state
+                    loss = self.best_loss
+                else:
+                    exit(1)
                             
             epoch_loss += loss
             current_step += 1

{flaxdiff-0.1.37.2 → flaxdiff-0.1.37.4}/flaxdiff.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flaxdiff
-Version: 0.1.37.2
+Version: 0.1.37.4
 Summary: A versatile and easy to understand Diffusion library
 Author-email: Ashish Kumar Singh <ashishkmr472@gmail.com>
 License-Expression: MIT

{flaxdiff-0.1.37.2 → flaxdiff-0.1.37.4}/flaxdiff.egg-info/SOURCES.txt

@@ -14,6 +14,8 @@ flaxdiff/data/online_loader.py
 flaxdiff/data/sources/gcs.py
 flaxdiff/data/sources/tfds.py
 flaxdiff/metrics/inception.py
+flaxdiff/metrics/psnr.py
+flaxdiff/metrics/ssim.py
 flaxdiff/metrics/utils.py
 flaxdiff/models/__init__.py
 flaxdiff/models/attention.py

{flaxdiff-0.1.37.2 → flaxdiff-0.1.37.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flaxdiff"
-version = "0.1.37.2"
+version = "0.1.37.4"
 description = "A versatile and easy to understand Diffusion library"
 readme = "README.md"
 authors = [