Update to ruff format

Author: palonso

src/cosineannealingscheduler.py

@@ -11,9 +11,9 @@ def __init__(self, optimizer, total_steps, warmup_steps, eta_min, last_epoch=-1)
         self.eta_min = eta_min
         super(CosineAnnealingWithWarmup, self).__init__(optimizer, last_epoch)
 
-        assert (
-            self.total_steps > self.warmup_steps
-        ), f"total_steps: {self.total_steps} must be greater than warmup_steps: {self.warmup_steps}"
+        assert self.total_steps > self.warmup_steps, (
+            f"total_steps: {self.total_steps} must be greater than warmup_steps: {self.warmup_steps}"
+        )
 
     def get_lr(self):
         if self.last_epoch < self.warmup_steps:

src/modules/maskingmodel.py

@@ -433,9 +433,9 @@ def extract_embeddings(
 
         # Compute the representation
         if isinstance(self.representation, nn.ModuleList):
-            assert (
-                self.input_representation is not None
-            ), "`input_representation` must be provided."
+            assert self.input_representation is not None, (
+                "`input_representation` must be provided."
+            )
             for rep in self.representation:
                 if isinstance(rep, self.input_representation):
                     input_rep = rep

src/nets/mlp.py

@@ -26,9 +26,9 @@ def __init__(
     def forward(self, x):
         x = x.reshape(x.size(0), -1)
 
-        assert (
-            x.shape[1] == self.input_shape[0]
-        ), f"Expected shape {self.input_shape}, got {x.shape}"
+        assert x.shape[1] == self.input_shape[0], (
+            f"Expected shape {self.input_shape}, got {x.shape}"
+        )
 
         x = self.l1(x)
         if self.hidden_shape:

src/nets/rope.py

@@ -53,9 +53,9 @@ def apply_rotary_emb(freqs, t, start_index=0, scale=1.0, seq_dim=-2):
     rot_dim = freqs.shape[-1]
     end_index = start_index + rot_dim
 
-    assert rot_dim <= t.shape[-1], (
-        f"feature dimension {t.shape[-1]} is not of sufficient size to rotate in all the positions {rot_dim}"
-    )
+    assert (
+        rot_dim <= t.shape[-1]
+    ), f"feature dimension {t.shape[-1]} is not of sufficient size to rotate in all the positions {rot_dim}"
 
     t_left, t, t_right = (
         t[..., :start_index],
@@ -173,9 +173,9 @@ def get_seq_pos(self, seq_len, device, dtype, offset=0):
     def rotate_queries_or_keys(self, t, seq_dim=None, offset=0, scale=None):
         seq_dim = default(seq_dim, self.default_seq_dim)
 
-        assert not self.use_xpos or exists(scale), (
-            "you must use `.rotate_queries_and_keys` method instead and pass in both queries and keys, for length extrapolatable rotary embeddings"
-        )
+        assert (
+            not self.use_xpos or exists(scale)
+        ), "you must use `.rotate_queries_and_keys` method instead and pass in both queries and keys, for length extrapolatable rotary embeddings"
 
         device, dtype, seq_len = t.device, t.dtype, t.shape[seq_dim]
 

src/prediction/dataset.py

@@ -39,7 +39,7 @@ def __init__(
         self.overlap_ratio = overlap_ratio
 
         self.n_frames = num_frames
-        self.n_seconds = self.n_frames / self.orig_freq
+        self.n_seconds = 30
 
         assert (
             self.overlap_ratio >= 0 and self.overlap_ratio < 1
@@ -57,18 +57,19 @@ def compute_segments_per_file(self):
 
         i = 0
         for filepath in tqdm(self.filelist):
-            try:
-                hop_size = self.n_seconds * self.overlap_ratio
+            # try:
+            hop_size = self.n_seconds * (1 - self.overlap_ratio)
 
-                metadata = torchaudio.info(self.data_dir / filepath)
-                seconds = metadata.num_frames / metadata.sample_rate
-                n_segments = int(seconds / hop_size)
+            metadata = torchaudio.info(self.data_dir / filepath)
+            seconds = metadata.num_frames / metadata.sample_rate
 
-                for j in range(n_segments):
-                    self.index[i] = (filepath, j)
-                    i += 1
-            except Exception as e:
-                print(f"Error processing file {filepath}")
+            n_segments = int(seconds / hop_size)
+
+            for j in range(n_segments):
+                self.index[i] = (filepath, j)
+                i += 1
+        # except Exception as e:
+        #     print(f"Error processing file {filepath}")
 
     def __len__(self):
         return len(self.index)
@@ -111,6 +112,9 @@ def __getitem__(self, idx):
                 audio = audio.float()
 
             # TODO zero pad
+            tgt_len = 720000
+            if audio.size(0) < tgt_len:
+                audio = torch.nn.functional.pad(audio, (0, tgt_len - audio.size(0)))
 
             return audio, str(file_path)