Merge pull request #59 from liebharc/feature/next_conv

ConvNext and data augmentation

Author: liebharc

Training.md

@@ -55,11 +55,74 @@ This validation provides a **more representative indication of overall system pe
 
 Implementation: `rate_validation_result.py`
 
+## Run 334
+
+Commit: 6d996c3d118c1e183f8412832383168e52630ce8
+Day: 17 Feb 2026  
+Transformer Smoke Test: SER 6%
+System Level: 10.2 diffs, SER: 13.6%
+
+convnextv2_base, https://github.com/liebharc/homr/pull/59
+
+## Run 333
+
+Commit: bb0ced2ff0cacdbd8ee33db4533a04c9e77f0ca8
+Day: 17 Feb 2026  
+Transformer Smoke Test: SER 18%
+System Level: 14.4 diffs, SER: 14.5%
+
+convnextv2_tiny, https://github.com/liebharc/homr/pull/59
+
+## Run 331
+
+Commit: e10346542968cc71fbcce0c0696f3ac963f11ae1
+Day: 17 Feb 2026  
+Transformer Smoke Test: SER 6%
+System Level: 5.3 diffs, SER: 3.4%
+
+Scheduled Sampling, https://github.com/liebharc/homr/pull/59
+
+## Run 328 Epch 21
+
+Commit: a78209527e2b8a4fb866fba9b2ef8540f4b8dad9
+Day: 14 Feb 2026  
+Transformer Smoke Test: SER 10%
+System Level: 16.0 diffs, SER: 9.3%
+
+Harder augmentation, https://github.com/liebharc/homr/pull/59
+
+## Run 326 Epoch 13
+
+Commit: 290d4e79aa377681523ca676b984b9cee3eb16ce
+Day: 13 Feb 2026  
+Transformer Smoke Test: SER 13%
+System Level: 42.8 diffs, SER: 32.8%
+
+Backtracking, removed 90deg rotation and sinusoidal bias, https://github.com/liebharc/homr/pull/59
+
+## Run 322 Epoch 14
+
+Commit: fd3d66d7d989003ec4cadd1d594ca2e820ece941
+Day: 12 Feb 2026  
+Transformer Smoke Test: SER 12%
+System Level: 18.1 diffs, SER: 22.4%
+
+Improved pitch accuracy, https://github.com/liebharc/homr/pull/59
+
+## Run 317
+
+Commit: 6f72a0bc2577907503e7ec84ac9850a5a972ded0
+Day: 4 Feb 2026  
+Transformer Smoke Test: SER 15%
+System Level: 25.9 diffs, SER: 15.5%
+
+ConvNext, https://github.com/liebharc/homr/pull/59
+
 ## Run 286 - after segnet update
 
 Commit: 87d30ed79a81b4f07a38a8f6419334c59633709a  
 Day: 30 Jan 2026  
-Transformer Smoke Test: SER 26%  
+Transformer Smoke Test: SER 14% (the SER reported for the previous runs was too large due to an unreasonable large temperature setting during the smoke test)
 System Level: 6.9 diffs, SER: 5.7%
 
 Updated segnet model for staff detection.
@@ -68,8 +131,8 @@ Updated segnet model for staff detection.
 
 Commit: 0daf75fea21e6ea6a865405e03a4bc7e73e9aa14  
 Day: 4 Jan 2026  
-Transformer Smoke Test: SER 26%  
-System levle: 7.4 diffs
+Transformer Smoke Test: SER 26% (higher, due to an error in the smoke test)
+System Level: 7.4 diffs
 
 After fixing an issue with accidentals during the conversion of the PrIMuS dataset Run 242 (a00be6debbedf617acdf39558c89ba6113c06af3)
 was used as basis of a 15 epoch run which only trained the lift decoder.
@@ -78,16 +141,16 @@ was used as basis of a 15 epoch run which only trained the lift decoder.
 
 Commit: a00be6debbedf617acdf39558c89ba6113c06af3  
 Day: 9 Dec 2025  
-Transformer Smoke Test: SER 23% after fixing some errors in the SER calculation itself, before 36%  
-System levle: 7.2 diffs after fixing an error in the validation result calculation itself, before 8.1
+Transformer Smoke Test: SER 23% (some errors in the smoke test fixed, still higher as some issue remained)
+System Level: 7.2 diffs after fixing an error in the validation result calculation itself, before 8.1
 
 Singe staff images now use the full resolution.
 
 ## Run 236
 
 Commit: 922ad08f8895f6d9c0ae61954cd78a021ff950a7  
 Day: 26 Oct 2025  
-Transformer Smoke Test: SER 37%  
+Transformer Smoke Test: SER 37% (higher, due to an error in the smoke test)
 System Level: 9.8 diffs, 8.6 after some tweaks to the staff image preparation
 
 Volta brackets, bf16
@@ -96,10 +159,10 @@ Volta brackets, bf16
 
 Commit:ea96f0150ec74388df8cb0bb78ee2c36782a00d9  
 Day: 01 Oct 2025  
-Transformer Smoke Test: SER 39%  
+Transformer Smoke Test: SER 39% (higher, due to an error in the smoke test)
 System Level: 9.8 diffs
 
-Grandstaff support. With the grandstaff support the SER numbers can't be directly compared to the previous runs anymore. Validations results still can be used for comparison.
+Grandstaff support.
 
 Some notes about other experiments which have been performed on the lieder dataset with only 15 epochs:
 

homr/staff_dewarping.py

@@ -373,7 +373,14 @@ def dewarp_staff_image(image: NDArray, staff: Staff, index: int, debug: Debug) -
 
 def warp_image_randomly(image: PIL.Image.Image) -> PIL.Image.Image:
     array = np.array(image)
-    result = warp_image_array_randomly(array)
+
+    # Randomly choose between two different warping algorithms
+    # to add more variety to the dewarping augmentation.
+    warp_algo = np.random.randint(0, 2)
+    if warp_algo == 0:
+        result = warp_image_array_randomly(array)
+    else:
+        result = warp_image_array_randomly2(array)
     return PIL.Image.fromarray(result)
 
 
@@ -393,8 +400,56 @@ def warp_image_array_randomly(image: NDArray) -> NDArray:
     ]
     result = calculate_dewarp_transformation(
         image, [upper, source, lower], [upper, destination, lower]
-    ).dewarp(image, order=3)
-    return (255 * result).astype(np.uint8)
+    ).dewarp(image, fill_color=255, order=3)
+
+    return result.astype(np.uint8)
+
+
+def warp_image_array_randomly2(image: NDArray) -> NDArray:
+    """
+    Apply a smooth random warp to the image to simulate paper folding/bending.
+    Uses cv2.remap with a 1D vertical displacement pattern (tiled horizontally)
+    to create a realistic wavy look without "hard cuts" or 2D stretching.
+    """
+    height, width = image.shape[:2]
+
+    # Use a small grid: 5 columns, 2 identical rows for vertical-only wave
+    grid_w = 5
+    grid_h = 2
+
+    # Generate random vertical displacement (same for both rows)
+    # alpha controls the maximum displacement in pixels
+    alpha = np.random.uniform(5, 25)
+    dy_row = np.random.uniform(-1, 1, (1, grid_w)).astype(np.float32)
+
+    # Anchor left and right edges to zero displacement
+    dy_row[0, 0] = 0
+    dy_row[0, -1] = 0
+
+    # Tile vertically to create a consistent wave across the entire image height
+    dy_small = np.tile(dy_row, (grid_h, 1))
+    dx_small = np.zeros((grid_h, grid_w), dtype=np.float32)
+
+    # Upscale to full image size with cubic interpolation for smoothness
+    dx = cv2.resize(dx_small, (width, height), interpolation=cv2.INTER_CUBIC) * alpha
+    dy = cv2.resize(dy_small, (width, height), interpolation=cv2.INTER_CUBIC) * alpha
+
+    # Create coordinate maps for cv2.remap
+    x, y = np.meshgrid(np.arange(width), np.arange(height))
+    map_x = (x + dx).astype(np.float32)
+    map_y = (y + dy).astype(np.float32)
+
+    # Perform the warping
+    result = cv2.remap(
+        image,
+        map_x,
+        map_y,
+        interpolation=cv2.INTER_LINEAR,
+        borderMode=cv2.BORDER_CONSTANT,
+        borderValue=(255, 255, 255),
+    )
+
+    return result.astype(np.uint8)
 
 
 if __name__ == "__main__":

homr/transformer/configs.py

@@ -10,7 +10,7 @@
 
 class FilePaths:
     def __init__(self) -> None:
-        model_name = "pytorch_model_286-0daf75fea21e6ea6a865405e03a4bc7e73e9aa14"
+        model_name = "pytorch_model_331-e10346542968cc71fbcce0c0696f3ac963f11ae1"
         self.encoder_path = os.path.join(
             workspace,
             f"encoder_{model_name}.onnx",
@@ -62,6 +62,9 @@ def __init__(self) -> None:
         self.ff_glu = True
         self.rel_pos_bias = False
         self.use_scalenorm = False
+        self.attn_dropout = 0.1
+        self.ff_dropout = 0.1
+        self.layer_dropout = 0.1
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -70,6 +73,9 @@ def to_dict(self) -> dict[str, Any]:
             "ff_glu": self.ff_glu,
             "rel_pos_bias": self.rel_pos_bias,
             "use_scalenorm": self.use_scalenorm,
+            "attn_dropout": self.attn_dropout,
+            "ff_dropout": self.ff_dropout,
+            "layer_dropout": self.layer_dropout,
         }
 
     def to_json_string(self) -> str:
@@ -94,15 +100,17 @@ def __init__(self) -> None:
         self.num_lift_tokens = len(self.vocab.lift)
         self.num_articulation_tokens = len(self.vocab.articulation)
         self.num_position_tokens = len(self.vocab.position)
-        self.encoder_structure = "hybrid"
+        self.encoder_structure = "convnext"
         self.encoder_depth = 8
         self.backbone_layers = [3, 4, 6, 3]
-        self.encoder_dim = 312
+        self.encoder_dim = 512
+        # encoder_h_dim balances how many dimensions the
+        # horizontal vs vertical embeddings get
+        self.encoder_h_dim = self.encoder_dim // 3
         self.encoder_heads = 8
-        self.decoder_dim = 312
+        self.decoder_dim = self.encoder_dim
         self.decoder_depth = 8
         self.decoder_heads = 8
-        self.temperature = 0.01
         self.decoder_args = DecoderArgs()
         self.lift_vocab = self.vocab.lift
         self.pitch_vocab = self.vocab.pitch
@@ -111,6 +119,11 @@ def __init__(self) -> None:
         self.position_vocab = self.vocab.position
         self.use_gpu_inference = True
 
+        # Scheduled Sampling parameters
+        self.scheduled_sampling_start_prob = 1.0
+        self.scheduled_sampling_end_prob = 0.7
+        self.scheduled_sampling_decay_steps = 20000
+
     def to_dict(self) -> dict[str, Any]:
         return {
             "filepaths": self.filepaths.to_dict(),
@@ -132,7 +145,6 @@ def to_dict(self) -> dict[str, Any]:
             "decoder_dim": self.decoder_dim,
             "decoder_depth": self.decoder_depth,
             "decoder_heads": self.decoder_heads,
-            "temperature": self.temperature,
             "decoder_args": self.decoder_args.to_dict(),
         }
 

homr/transformer/decoder_inference.py

@@ -1,12 +1,10 @@
-from math import ceil
 from typing import Any
 
 import numpy as np
 import onnxruntime as ort
 
 from homr.simple_logging import eprint
 from homr.transformer.configs import Config
-from homr.transformer.utils import softmax
 from homr.transformer.vocabulary import EncodedSymbol
 from homr.type_definitions import NDArray
 
@@ -22,6 +20,7 @@ def __init__(
     ):
         super().__init__()
         self.ignore_index = ignore_index
+        self.config = config
         self.net = transformer
         self.io_binding = self.net.io_binding()
         self.max_seq_len = config.max_seq_len
@@ -49,8 +48,6 @@ def generate(
         self,
         start_tokens: NDArray,
         nonote_tokens: NDArray,
-        temperature: float = 1.0,
-        filter_thres: float = 0.7,
         **kwargs: Any,
     ) -> list[EncodedSymbol]:
         num_dims = len(start_tokens.shape)
@@ -103,32 +100,19 @@ def generate(
             outputs = self.io_binding.get_outputs()
             cache = outputs[6:]
 
-            # And convert the outputs to np arrays...
+            # Greedy decoding: pick the highest logit directly for each output
             rhythmsp = outputs[0].numpy()
             pitchsp = outputs[1].numpy()
             liftsp = outputs[2].numpy()
             positionsp = outputs[3].numpy()
             articulationsp = outputs[4].numpy()
             attention = outputs[5].numpy()
 
-            # ...To continue with the normal CPU based processing
-            filtered_lift_logits = top_k(liftsp[:, -1, :], thres=filter_thres)
-            filtered_pitch_logits = top_k(pitchsp[:, -1, :], thres=filter_thres)
-            filtered_rhythm_logits = top_k(rhythmsp[:, -1, :], thres=filter_thres)
-            filtered_articulations_logits = top_k(articulationsp[:, -1, :], thres=filter_thres)
-            filtered_positions_logits = top_k(positionsp[:, -1, :], thres=filter_thres)
-
-            lift_probs = softmax(filtered_lift_logits / temperature, dim=-1)
-            pitch_probs = softmax(filtered_pitch_logits / temperature, dim=-1)
-            rhythm_probs = softmax(filtered_rhythm_logits / temperature, dim=-1)
-            articulation_probs = softmax(filtered_articulations_logits / temperature, dim=-1)
-            positions_probs = softmax(filtered_positions_logits / temperature, dim=-1)
-
-            lift_sample = np.array([[lift_probs.argmax()]])
-            pitch_sample = np.array([[pitch_probs.argmax()]])
-            rhythm_sample = np.array([[rhythm_probs.argmax()]])
-            articulation_sample = np.array([[articulation_probs.argmax()]])
-            position_sample = np.array([[positions_probs.argmax()]])
+            rhythm_sample = np.array([[rhythmsp[:, -1, :].argmax()]])
+            pitch_sample = np.array([[pitchsp[:, -1, :].argmax()]])
+            lift_sample = np.array([[liftsp[:, -1, :].argmax()]])
+            articulation_sample = np.array([[articulationsp[:, -1, :].argmax()]])
+            position_sample = np.array([[positionsp[:, -1, :].argmax()]])
 
             lift_token = detokenize(lift_sample, self.inv_lift_vocab)
             pitch_token = detokenize(pitch_sample, self.inv_pitch_vocab)
@@ -160,19 +144,21 @@ def init_cache(self, cache_len: int = 0) -> tuple[list[NDArray], list[str], list
         cache = []
         input_names = []
         output_names = []
-        for i in range(32):
+        heads = self.config.decoder_heads
+        head_dim = self.config.decoder_dim // heads
+        for i in range(self.config.decoder_depth * 4):
             if self.fp16:  # the cache needs to be fp16 as well
                 cache.append(
                     ort.OrtValue.ortvalue_from_numpy(
-                        np.zeros((1, 8, cache_len, 64), dtype=np.float16),
+                        np.zeros((1, heads, cache_len, head_dim), dtype=np.float16),
                         "cuda" if self.use_gpu else "cpu",
                         self.device_id,
                     )
                 )
             else:
                 cache.append(
                     ort.OrtValue.ortvalue_from_numpy(
-                        np.zeros((1, 8, cache_len, 64), dtype=np.float32),
+                        np.zeros((1, heads, cache_len, head_dim), dtype=np.float32),
                         "cuda" if self.use_gpu else "cpu",
                         self.device_id,
                     )
@@ -182,30 +168,6 @@ def init_cache(self, cache_len: int = 0) -> tuple[list[NDArray], list[str], list
         return cache, input_names, output_names
 
 
-def top_k(logits: NDArray, thres: float = 0.9) -> NDArray:
-    """Numpy implementation matching torch's top_k behavior"""
-    k = ceil((1 - thres) * logits.shape[-1])
-
-    # Get top k elements
-    flat_logits = logits.ravel()
-    indices = np.argpartition(flat_logits, -k)[-k:]  # Get indices of top k elements
-    indices = indices[np.argsort(-flat_logits[indices])]  # Sort them in descending order
-    values = flat_logits[indices]  # Get the corresponding values
-
-    # Create output array with -inf
-    output = np.full_like(logits, -np.inf)
-
-    # Scatter the topk values back into the output array
-    # For multi-dimensional arrays, we need to convert flat indices to multi-indices
-    if logits.ndim > 1:
-        multi_indices = np.unravel_index(indices, logits.shape)
-        output[multi_indices] = values
-    else:
-        output[indices] = values
-
-    return output
-
-
 def detokenize(tokens: NDArray, vocab: dict[int, str]) -> list[str]:
     toks = [vocab[tok.item()] for tok in tokens]
     toks = [t for t in toks if t not in ("[BOS]", "[EOS]", "[PAD]")]