Further deduplication of progressive / multi-image size training validation

Author: rwightman

tests/test_scheduled_sampler.py

@@ -86,6 +86,16 @@ def test_constant_schedule_ignores_progressive_only_options():
     assert len(batch_sampler) > 0
 
 
+def test_progressive_schedule_requires_multiple_choices():
+    with pytest.raises(ValueError, match='at least two'):
+        ScheduledBatchSampler(
+            SequentialSampler(range(32)),
+            batch_sizes=(8,),
+            choice_schedule='progressive',
+            schedule_epochs=3,
+        )
+
+
 def test_zero_weight_choices_are_excluded_from_progressive_random_mix_and_sample_budget():
     progressive_sampler = ScheduledBatchSampler(
         SequentialSampler(range(64)),
@@ -343,6 +353,22 @@ def test_create_loader_scheduled_resolutions_default_to_batch_size():
     assert all(images.shape[0] == 4 for images, _ in loader)
 
 
+@pytest.mark.parametrize('invalid_size', (0, (16, 0), (3, 16, 0)))
+def test_create_loader_rejects_nonpositive_scheduled_dimensions(invalid_size):
+    with pytest.raises(ValueError, match='dimensions must be positive'):
+        create_loader(
+            _ImageDataset(),
+            input_size=(3, 32, 32),
+            batch_size=4,
+            input_size_choices=(invalid_size, 16),
+            is_training=True,
+            no_aug=True,
+            use_prefetcher=False,
+            num_workers=0,
+            persistent_workers=False,
+        )
+
+
 def test_create_loader_progressive_resolutions_keep_default_batch_and_sample_counts():
     loader = create_loader(
         _ImageDataset(length=96),

timm/data/loader.py

@@ -372,6 +372,8 @@ def create_loader(
                     raise ValueError('All scheduled input sizes must use the same number of channels.')
             else:
                 raise ValueError('Scheduled input sizes must be scalars, HW tuples, or CHW tuples.')
+            if any(dimension <= 0 for dimension in size):
+                raise ValueError('All scheduled input size dimensions must be positive.')
             resolved_input_sizes.append(size)
 
         if batch_size_choices is None:

timm/data/scheduled_sampler.py

@@ -70,6 +70,8 @@ def __init__(
         if choice_schedule not in ('constant', 'progressive'):
             raise ValueError("choice_schedule must be 'constant' or 'progressive'.")
         if choice_schedule == 'progressive':
+            if len(batch_sizes) < 2:
+                raise ValueError('A progressive schedule requires at least two choices.')
             if schedule_epochs is None or int(schedule_epochs) != schedule_epochs or schedule_epochs <= 0:
                 raise ValueError('schedule_epochs must be a positive integer for a progressive schedule.')
             if schedule_spread < 0:

train.py

@@ -502,35 +502,6 @@ def main():
         parser.error('--naflex-loader and --train-img-sizes are alternative loader modes.')
     if args.naflex_loader and args.use_multi_epochs_loader:
         parser.error('--use-multi-epochs-loader is not supported with --naflex-loader.')
-    if args.train_img_sizes is not None and args.use_multi_epochs_loader:
-        parser.error('--use-multi-epochs-loader is not supported with --train-img-sizes.')
-    if args.train_img_sizes is not None:
-        if any(size <= 0 for size in args.train_img_sizes):
-            parser.error('--train-img-sizes values must be positive.')
-        if args.train_batch_sizes is not None:
-            if len(args.train_batch_sizes) != len(args.train_img_sizes):
-                parser.error('--train-batch-sizes must have the same length as --train-img-sizes.')
-            if any(batch_size <= 0 for batch_size in args.train_batch_sizes):
-                parser.error('--train-batch-sizes values must be positive.')
-        if args.train_size_probs is not None:
-            if len(args.train_size_probs) != len(args.train_img_sizes):
-                parser.error('--train-size-probs must have the same length as --train-img-sizes.')
-            probs = torch.tensor(args.train_size_probs)
-            if not torch.isfinite(probs).all() or (probs < 0).any() or probs.sum() <= 0:
-                parser.error('--train-size-probs must be finite, non-negative, and have a positive sum.')
-        if args.aug_splits > 0:
-            parser.error('Augmentation splits are not supported with scheduled resolution training.')
-        if args.train_size_schedule == 'progressive':
-            if len(args.train_img_sizes) < 2:
-                parser.error('Progressive resolution training requires at least two --train-img-sizes values.')
-            if args.epochs <= 0:
-                parser.error('--epochs must be positive for progressive resolution training.')
-            if args.train_size_schedule_spread < 0:
-                parser.error('--train-size-schedule-spread must be non-negative.')
-            if not 0 <= args.train_size_random_mix <= 1:
-                parser.error('--train-size-random-mix must be between 0 and 1.')
-        if args.train_batches_per_epoch is not None and args.train_batches_per_epoch <= 0:
-            parser.error('--train-batches-per-epoch must be positive.')
     device = utils.init_distributed_device(args)
     if args.distributed:
         _logger.info(