omnigenome 0.3.0a0__py3-none-any.whl → 0.3.1a0__py3-none-any.whl

tests/test_training_patterns.py

@@ -1,302 +0,0 @@
-"""
-Test training patterns and configurations based on examples.
-"""
-import pytest
-from unittest.mock import patch, MagicMock
-
-
-class TestTrainingPatterns:
-    """Test training patterns from examples."""
-
-    def test_trainer_imports(self):
-        """Test trainer imports as shown in quick_start.md."""
-        try:
-            from omnigenome import Trainer
-            assert True
-        except ImportError:
-            pytest.skip("omnigenome not available or missing dependencies")
-
-    def test_autobench_imports(self):
-        """Test AutoBench imports from examples."""
-        try:
-            from omnigenome import AutoBench
-            assert True
-        except ImportError:
-            pytest.skip("omnigenome not available or missing dependencies")
-
-    def test_autocuda_import_pattern(self):
-        """Test autocuda import pattern from examples."""
-        try:
-            import autocuda
-            # Pattern from examples
-            device = autocuda.auto_cuda()
-            # Just verify the function exists and returns something
-            assert device is not None
-        except ImportError:
-            # Skip if autocuda not available
-            pytest.skip("autocuda not available")
-
-    @patch('omnigenome.AutoBench')
-    def test_autobench_initialization_pattern(self, mock_autobench):
-        """Test AutoBench initialization pattern from quick_start.md."""
-        mock_instance = MagicMock()
-        mock_autobench.return_value = mock_instance
-        
-        from omnigenome import AutoBench
-        
-        # Pattern from quick_start.md
-        auto_bench = AutoBench(
-            benchmark="RGB",
-            model_name_or_path="yangheng/OmniGenome-186M",
-            device="cuda:0",
-            overwrite=True
-        )
-        
-        mock_autobench.assert_called_once_with(
-            benchmark="RGB",
-            model_name_or_path="yangheng/OmniGenome-186M",
-            device="cuda:0",
-            overwrite=True
-        )
-
-    def test_benchmark_names(self):
-        """Test benchmark names from examples."""
-        # Benchmarks from quick_start.md
-        benchmarks = ["RGB", "GB", "PGB", "GUE", "BEACON"]
-        
-        for benchmark in benchmarks:
-            assert isinstance(benchmark, str)
-            assert len(benchmark) > 0
-            assert benchmark.isupper()
-
-    def test_trainer_names(self):
-        """Test trainer types from examples."""
-        # Trainers from autobench examples
-        trainers = ["accelerate", "huggingface"]
-        
-        for trainer in trainers:
-            assert isinstance(trainer, str)
-            assert trainer in ["accelerate", "huggingface"]
-
-    @patch('omnigenome.Trainer')
-    def test_trainer_initialization_pattern(self, mock_trainer):
-        """Test Trainer initialization pattern from quick_start.md."""
-        mock_trainer.return_value = MagicMock()
-        
-        from omnigenome import Trainer
-        
-        # Mock training arguments
-        mock_args = MagicMock()
-        mock_args.output_dir = "./results"
-        mock_args.num_train_epochs = 3
-        mock_args.per_device_train_batch_size = 8
-        mock_args.learning_rate = 2e-5
-        
-        # Pattern from quick_start.md
-        trainer = Trainer(
-            model=MagicMock(),
-            train_dataset=MagicMock(),
-            eval_dataset=MagicMock(),
-            args=mock_args
-        )
-        
-        mock_trainer.assert_called_once()
-
-    def test_training_arguments_pattern(self):
-        """Test training arguments patterns from examples."""
-        # Common training parameters from examples
-        training_configs = {
-            "output_dir": "./results",
-            "num_train_epochs": 3,
-            "per_device_train_batch_size": 8,
-            "learning_rate": 2e-5,
-            "epochs": 3,
-            "batch_size": 8,
-            "seeds": [42, 43, 44]
-        }
-        
-        # Verify types and ranges
-        assert isinstance(training_configs["output_dir"], str)
-        assert isinstance(training_configs["num_train_epochs"], int)
-        assert training_configs["num_train_epochs"] > 0
-        assert isinstance(training_configs["per_device_train_batch_size"], int)
-        assert training_configs["per_device_train_batch_size"] > 0
-        assert isinstance(training_configs["learning_rate"], float)
-        assert training_configs["learning_rate"] > 0
-        assert isinstance(training_configs["seeds"], list)
-        assert all(isinstance(seed, int) for seed in training_configs["seeds"])
-
-    def test_genetic_algorithm_parameters(self):
-        """Test genetic algorithm parameters from RNA design examples."""
-        # Parameters from easy_rna_design_emoo.py
-        ga_params = {
-            "mutation_ratio": 0.1,
-            "num_population": 100,
-            "num_generation": 50,
-            "model": "anonymous8/OmniGenome-186M"
-        }
-        
-        # Verify parameter types and ranges
-        assert isinstance(ga_params["mutation_ratio"], float)
-        assert 0.0 <= ga_params["mutation_ratio"] <= 1.0
-        assert isinstance(ga_params["num_population"], int)
-        assert ga_params["num_population"] > 0
-        assert isinstance(ga_params["num_generation"], int)
-        assert ga_params["num_generation"] > 0
-        assert isinstance(ga_params["model"], str)
-
-    def test_web_rna_design_parameters(self):
-        """Test web RNA design parameters from web_rna_design.py."""
-        # Parameters from web_rna_design.py
-        web_params = {
-            "mutation_ratio": 0.5,
-            "num_population": 500,
-            "num_generation": 10,
-            "puzzle_id": 0
-        }
-        
-        # Verify parameter types
-        assert isinstance(web_params["mutation_ratio"], float)
-        assert 0.0 <= web_params["mutation_ratio"] <= 1.0
-        assert isinstance(web_params["num_population"], int)
-        assert web_params["num_population"] > 0
-        assert isinstance(web_params["num_generation"], int)
-        assert web_params["num_generation"] > 0
-        assert isinstance(web_params["puzzle_id"], int)
-        assert web_params["puzzle_id"] >= 0
-
-    def test_model_optimization_patterns(self):
-        """Test model optimization patterns from examples."""
-        # Patterns from examples for model optimization
-        optimization_configs = {
-            "torch_dtype": "float16",
-            "device_map": "auto",
-            "trust_remote_code": True,
-            "gradient_checkpointing": True,
-            "fp16": True
-        }
-        
-        for key, value in optimization_configs.items():
-            assert isinstance(key, str)
-            # Value types vary, just ensure they exist
-            assert value is not None
-
-    @patch('torch.cuda.empty_cache')
-    def test_memory_management_pattern(self, mock_empty_cache):
-        """Test memory management patterns from web_rna_design.py."""
-        try:
-            import torch
-        except ImportError:
-            pytest.skip("torch not available")
-            
-        # Pattern from web_rna_design.py
-        def cleanup_model_pattern():
-            """Memory cleanup pattern from examples."""
-            # del model, tokenizer  # Would normally delete objects
-            torch.cuda.empty_cache()
-        
-        cleanup_model_pattern()
-        mock_empty_cache.assert_called_once()
-
-    def test_random_seed_patterns(self):
-        """Test random seed patterns from examples."""
-        import random
-        
-        # Pattern from examples
-        def set_random_seed_pattern():
-            """Random seed pattern from easy_rna_design_emoo.py."""
-            return random.randint(0, 99999999)
-        
-        # Test seed generation
-        seed1 = set_random_seed_pattern()
-        seed2 = set_random_seed_pattern()
-        
-        assert isinstance(seed1, int)
-        assert isinstance(seed2, int)
-        assert 0 <= seed1 <= 99999999
-        assert 0 <= seed2 <= 99999999
-
-    def test_evaluation_metrics_patterns(self):
-        """Test evaluation metrics patterns from examples."""
-        # Common metrics mentioned in examples
-        metrics = [
-            "accuracy",
-            "f1_score", 
-            "precision",
-            "recall",
-            "mse",
-            "mae",
-            "r2_score"
-        ]
-        
-        for metric in metrics:
-            assert isinstance(metric, str)
-            assert len(metric) > 0
-
-    def test_device_selection_patterns(self):
-        """Test device selection patterns from examples."""
-        # Patterns from examples
-        device_patterns = [
-            "cuda:0",
-            "cuda",
-            "cpu",
-            "auto"
-        ]
-        
-        for device in device_patterns:
-            assert isinstance(device, str)
-            assert len(device) > 0
-
-    def test_batch_size_patterns(self):
-        """Test batch size patterns from examples."""
-        # Common batch sizes from examples
-        batch_sizes = [4, 8, 16, 32, 64]
-        
-        for batch_size in batch_sizes:
-            assert isinstance(batch_size, int)
-            assert batch_size > 0
-            assert batch_size <= 1024  # Reasonable upper limit
-
-    def test_learning_rate_patterns(self):
-        """Test learning rate patterns from examples."""
-        # Common learning rates from examples
-        learning_rates = [1e-5, 2e-5, 5e-5, 1e-4, 2e-4]
-        
-        for lr in learning_rates:
-            assert isinstance(lr, float)
-            assert lr > 0
-            assert lr < 1.0  # Should be small
-
-    def test_epoch_patterns(self):
-        """Test epoch patterns from examples."""
-        # Common epoch counts from examples
-        epoch_counts = [1, 3, 5, 10, 20]
-        
-        for epochs in epoch_counts:
-            assert isinstance(epochs, int)
-            assert epochs > 0
-            assert epochs <= 100  # Reasonable upper limit
-
-    def test_output_directory_patterns(self):
-        """Test output directory patterns from examples."""
-        # Common output directory patterns
-        output_dirs = [
-            "./results",
-            "./output", 
-            "./checkpoints",
-            "./models"
-        ]
-        
-        for output_dir in output_dirs:
-            assert isinstance(output_dir, str)
-            assert output_dir.startswith("./") or output_dir.startswith("/")
-
-    def test_model_saving_patterns(self):
-        """Test model saving patterns from examples."""
-        # File extensions for saved models
-        model_extensions = [".pt", ".pth", ".bin", ".safetensors"]
-        
-        for ext in model_extensions:
-            assert isinstance(ext, str)
-            assert ext.startswith(".")
-            assert len(ext) > 1