isagellm-core 0.4.0.9__tar.gz → 0.4.0.11__tar.gz

{isagellm_core-0.4.0.9/src/isagellm_core.egg-info → isagellm_core-0.4.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isagellm-core
-Version: 0.4.0.9
+Version: 0.4.0.11
 Summary: sageLLM core runtime with PD separation (MVP)
 Author: IntelliStream Team
 License: Proprietary - IntelliStream

{isagellm_core-0.4.0.9 → isagellm_core-0.4.0.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "isagellm-core"
-version = "0.4.0.9"
+version = "0.4.0.11"
 description = "sageLLM core runtime with PD separation (MVP)"
 readme = "README.md"
 requires-python = "==3.11.*"

{isagellm_core-0.4.0.9 → isagellm_core-0.4.0.11/src/isagellm_core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isagellm-core
-Version: 0.4.0.9
+Version: 0.4.0.11
 Summary: sageLLM core runtime with PD separation (MVP)
 Author: IntelliStream Team
 License: Proprietary - IntelliStream

{isagellm_core-0.4.0.9 → isagellm_core-0.4.0.11}/src/isagellm_core.egg-info/SOURCES.txt

@@ -41,6 +41,19 @@ src/sagellm_core/__pycache__/plugins.cpython-311.pyc
 src/sagellm_core/__pycache__/runner.cpython-311.pyc
 src/sagellm_core/__pycache__/runtime.cpython-311.pyc
 src/sagellm_core/__pycache__/workload.cpython-311.pyc
+src/sagellm_core/decoding/__init__.py
+src/sagellm_core/decoding/__init__.pyc
+src/sagellm_core/decoding/base.pyc
+src/sagellm_core/decoding/beam_search.pyc
+src/sagellm_core/decoding/contrastive.pyc
+src/sagellm_core/decoding/greedy.pyc
+src/sagellm_core/decoding/sampling.pyc
+src/sagellm_core/decoding/__pycache__/__init__.cpython-311.pyc
+src/sagellm_core/decoding/__pycache__/base.cpython-311.pyc
+src/sagellm_core/decoding/__pycache__/beam_search.cpython-311.pyc
+src/sagellm_core/decoding/__pycache__/contrastive.cpython-311.pyc
+src/sagellm_core/decoding/__pycache__/greedy.cpython-311.pyc
+src/sagellm_core/decoding/__pycache__/sampling.cpython-311.pyc
 src/sagellm_core/distributed/__init__.py
 src/sagellm_core/distributed/__init__.pyc
 src/sagellm_core/distributed/strategies.pyc
@@ -114,12 +127,14 @@ src/sagellm_core/worker/model_runner/__pycache__/__init__.cpython-311.pyc
 src/sagellm_core/worker/model_runner/__pycache__/model_runner.cpython-311.pyc
 tests/test_ci_smoke.py
 tests/test_config.py
+tests/test_decoding_strategies.py
 tests/test_e2e_llm_integration.py
 tests/test_engine.py
 tests/test_engine_behavior_parity.py
 tests/test_engine_contract_simplified.py
 tests/test_engine_server.py
 tests/test_llm_engine_contract.py
+tests/test_llm_engine_decoding.py
 tests/test_llm_engine_error_handling.py
 tests/test_model_loader.py
 tests/test_observability.py

{isagellm_core-0.4.0.9 → isagellm_core-0.4.0.11}/src/sagellm_core/__init__.py

@@ -26,7 +26,7 @@ Architecture (vLLM v1 style):
 
 from __future__ import annotations
 
-__version__ = "0.4.0.9"
+__version__ = "0.4.0.11"
 
 # ============================================================================
 # New Architecture (vLLM v1 style) - Hardware Agnostic

isagellm_core-0.4.0.11/src/sagellm_core/decoding/__init__.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from sagellm_protocol.sampling import DecodingStrategy, SamplingParams
+
+from sagellm_core.decoding.base import DecodingStrategyBase
+from sagellm_core.decoding.beam_search import BeamSearchDecoding
+from sagellm_core.decoding.contrastive import ContrastiveSearchDecoding
+from sagellm_core.decoding.greedy import GreedyDecoding
+from sagellm_core.decoding.sampling import SamplingDecoding
+
+
+def create_decoding_strategy(params: SamplingParams) -> DecodingStrategyBase:
+    """工厂函数：根据 SamplingParams 创建解码策略
+
+    Args:
+        params: 采样参数配置
+
+    Returns:
+        对应的解码策略实例
+
+    Raises:
+        ValueError: 不支持的解码策略
+    """
+    if params.strategy == DecodingStrategy.GREEDY:
+        return GreedyDecoding(params)
+    elif params.strategy == DecodingStrategy.SAMPLING:
+        return SamplingDecoding(params)
+    elif params.strategy == DecodingStrategy.BEAM_SEARCH:
+        return BeamSearchDecoding(params)
+    elif params.strategy == DecodingStrategy.CONTRASTIVE:
+        return ContrastiveSearchDecoding(params)
+    else:
+        raise ValueError(f"Unsupported decoding strategy: {params.strategy}")
+
+
+__all__ = [
+    "DecodingStrategyBase",
+    "GreedyDecoding",
+    "SamplingDecoding",
+    "BeamSearchDecoding",
+    "ContrastiveSearchDecoding",
+    "create_decoding_strategy",
+]

isagellm_core-0.4.0.11/tests/test_decoding_strategies.py

@@ -0,0 +1,192 @@
+"""Tests for decoding strategies"""
+
+from __future__ import annotations
+
+import pytest
+
+from sagellm_protocol.sampling import DecodingStrategy, SamplingParams
+
+from sagellm_core.decoding import (
+    BeamSearchDecoding,
+    ContrastiveSearchDecoding,
+    GreedyDecoding,
+    SamplingDecoding,
+    create_decoding_strategy,
+)
+
+
+class TestSamplingParamsInference:
+    """Test SamplingParams automatic strategy inference
+
+    用户可以通过参数推断策略，而不是显式指定 strategy。
+    例如：temperature > 1.0 自动触发 SAMPLING 策略。
+    """
+
+    def test_default_is_greedy(self):
+        """默认应该是贪婪解码"""
+        params = SamplingParams()
+        assert params.strategy == DecodingStrategy.GREEDY
+        # Note: is_greedy 等辅助属性需要在 sagellm-protocol 中实现
+
+    def test_explicit_greedy(self):
+        """显式指定 GREEDY 策略"""
+        params = SamplingParams(strategy=DecodingStrategy.GREEDY)
+        assert params.strategy == DecodingStrategy.GREEDY
+
+    def test_explicit_sampling(self):
+        """显式指定 SAMPLING 策略（即使 temperature=1.0）"""
+        params = SamplingParams(strategy=DecodingStrategy.SAMPLING, temperature=0.7)
+        assert params.strategy == DecodingStrategy.SAMPLING
+
+    def test_explicit_beam_search(self):
+        """显式指定 BEAM_SEARCH 策略"""
+        params = SamplingParams(strategy=DecodingStrategy.BEAM_SEARCH, beam_size=5)
+        assert params.strategy == DecodingStrategy.BEAM_SEARCH
+
+    def test_explicit_contrastive(self):
+        """显式指定 CONTRASTIVE 策略"""
+        params = SamplingParams(
+            strategy=DecodingStrategy.CONTRASTIVE,
+            penalty_alpha=0.6,
+        )
+        assert params.strategy == DecodingStrategy.CONTRASTIVE
+
+
+class TestGreedyDecoding:
+    """Test greedy decoding strategy"""
+
+    def test_greedy_basic(self):
+        """Test basic greedy decoding"""
+        params = SamplingParams(strategy=DecodingStrategy.GREEDY, max_tokens=100)
+        strategy = GreedyDecoding(params)
+
+        assert strategy.get_strategy_name() == "Greedy Decoding"
+
+        kwargs = strategy.to_generate_kwargs()
+        assert kwargs["max_new_tokens"] == 100
+        assert kwargs["do_sample"] is False
+        assert "pad_token_id" in kwargs
+
+
+class TestSamplingDecoding:
+    """Test temperature sampling strategy"""
+
+    def test_sampling_basic(self):
+        """Test basic temperature sampling"""
+        params = SamplingParams(
+            strategy=DecodingStrategy.SAMPLING, temperature=0.7, top_p=0.9, max_tokens=200
+        )
+        strategy = SamplingDecoding(params)
+
+        assert "Temperature Sampling" in strategy.get_strategy_name()
+
+        kwargs = strategy.to_generate_kwargs()
+        assert kwargs["max_new_tokens"] == 200
+        assert kwargs["do_sample"] is True
+        assert kwargs["temperature"] == 0.7
+        assert kwargs["top_p"] == 0.9
+
+    def test_sampling_with_top_k(self):
+        """Test sampling with top_k"""
+        params = SamplingParams(
+            strategy=DecodingStrategy.SAMPLING,
+            temperature=0.8,
+            top_k=50,
+            max_tokens=150,
+        )
+        strategy = SamplingDecoding(params)
+
+        kwargs = strategy.to_generate_kwargs()
+        assert kwargs["top_k"] == 50
+
+    def test_sampling_with_repetition_penalty(self):
+        """Test sampling with repetition penalty"""
+        params = SamplingParams(
+            strategy=DecodingStrategy.SAMPLING,
+            temperature=0.7,
+            repetition_penalty=1.2,
+            max_tokens=150,
+        )
+        strategy = SamplingDecoding(params)
+
+        kwargs = strategy.to_generate_kwargs()
+        assert kwargs["repetition_penalty"] == 1.2
+
+
+class TestBeamSearchDecoding:
+    """Test beam search strategy"""
+
+    def test_beam_search_basic(self):
+        """Test basic beam search"""
+        params = SamplingParams(
+            strategy=DecodingStrategy.BEAM_SEARCH,
+            beam_size=5,
+            length_penalty=0.8,
+            max_tokens=150,
+        )
+        strategy = BeamSearchDecoding(params)
+
+        assert "Beam Search" in strategy.get_strategy_name()
+        assert "beams=5" in strategy.get_strategy_name()
+
+        kwargs = strategy.to_generate_kwargs()
+        assert kwargs["max_new_tokens"] == 150
+        assert kwargs["num_beams"] == 5
+        assert kwargs["length_penalty"] == 0.8
+        assert kwargs["early_stopping"] is True
+
+
+class TestContrastiveSearchDecoding:
+    """Test contrastive search strategy"""
+
+    def test_contrastive_basic(self):
+        """Test basic contrastive search"""
+        params = SamplingParams(
+            strategy=DecodingStrategy.CONTRASTIVE, penalty_alpha=0.6, max_tokens=300
+        )
+        strategy = ContrastiveSearchDecoding(params)
+
+        assert "Contrastive Search" in strategy.get_strategy_name()
+        assert "alpha=0.60" in strategy.get_strategy_name()
+
+        kwargs = strategy.to_generate_kwargs()
+        assert kwargs["max_new_tokens"] == 300
+        assert kwargs["penalty_alpha"] == 0.6
+        assert kwargs["top_k"] == 4  # Default for contrastive search
+
+
+class TestDecodingStrategyFactory:
+    """Test strategy factory function"""
+
+    def test_create_greedy(self):
+        """Test creating greedy strategy"""
+        params = SamplingParams(strategy=DecodingStrategy.GREEDY)
+        strategy = create_decoding_strategy(params)
+        assert isinstance(strategy, GreedyDecoding)
+
+    def test_create_sampling(self):
+        """Test creating sampling strategy"""
+        params = SamplingParams(strategy=DecodingStrategy.SAMPLING, temperature=0.7)
+        strategy = create_decoding_strategy(params)
+        assert isinstance(strategy, SamplingDecoding)
+
+    def test_create_beam_search(self):
+        """Test creating beam search strategy"""
+        params = SamplingParams(strategy=DecodingStrategy.BEAM_SEARCH, beam_size=4)
+        strategy = create_decoding_strategy(params)
+        assert isinstance(strategy, BeamSearchDecoding)
+
+    def test_create_contrastive(self):
+        """Test creating contrastive strategy"""
+        params = SamplingParams(strategy=DecodingStrategy.CONTRASTIVE, penalty_alpha=0.6)
+        strategy = create_decoding_strategy(params)
+        assert isinstance(strategy, ContrastiveSearchDecoding)
+
+    def test_unsupported_strategy(self):
+        """Test unsupported strategy raises error"""
+        params = SamplingParams(strategy=DecodingStrategy.GREEDY)
+        # Manually set invalid strategy
+        params.strategy = "invalid_strategy"  # type: ignore
+
+        with pytest.raises(ValueError, match="Unsupported decoding strategy"):
+            create_decoding_strategy(params)

{isagellm_core-0.4.0.9 → isagellm_core-0.4.0.11}/tests/test_engine.py

@@ -162,13 +162,13 @@ def test_health_status_enum() -> None:
 @pytest.mark.skip(reason="TestCPUEngine has been removed in favor of LLMEngine")
 def test_create_cpu_test_engine() -> None:
     """Test creating lightweight CPU test engine instance"""
-    config = EngineInstanceConfig(engine_id="test-cpu-1", model_path="sshleifer/tiny-gpt2")
-    engine = TestCPUEngine(config)
-
-    assert engine is not None
-    assert hasattr(engine, "start")
-    assert hasattr(engine, "execute")
-    assert hasattr(engine, "stream")
+    # config = EngineInstanceConfig(engine_id="test-cpu-1", model_path="sshleifer/tiny-gpt2")
+    # engine = TestCPUEngine(config)
+    # assert engine is not None
+    # assert hasattr(engine, "start")
+    # assert hasattr(engine, "execute")
+    # assert hasattr(engine, "stream")
+    pass
 
 
 def test_create_engine_invalid_config() -> None:
@@ -234,6 +234,7 @@ async def test_engine_execute() -> None:
 
 
 @pytest.mark.asyncio
+@pytest.mark.timeout(180)  # 增加超时时间到 3 分钟
 async def test_engine_stream() -> None:
     """Test engine streaming"""
     from sagellm_core import LLMEngine
@@ -299,7 +300,9 @@ async def test_engine_get_info() -> None:
     pass
 
 
-@pytest.mark.skip(reason="LLMEngine does not have class methods is_available(), priority(), backend_type()")
+@pytest.mark.skip(
+    reason="LLMEngine does not have class methods is_available(), priority(), backend_type()"
+)
 def test_engine_class_methods() -> None:
     """Test Engine class methods (skipped - these are implementation details)"""
     pass

isagellm_core-0.4.0.11/tests/test_llm_engine_decoding.py

@@ -0,0 +1,108 @@
+"""集成测试：LLMEngine + 解码策略系统
+
+测试 LLMEngine 与解码策略的完整集成，包括：
+- 默认贪婪解码行为
+- 向后兼容的参数传递
+- SamplingParams 对象使用
+- 参数优先级处理
+"""
+
+from __future__ import annotations
+
+import pytest
+import pytest_asyncio
+
+from sagellm_core import LLMEngine, LLMEngineConfig
+from sagellm_protocol.sampling import DecodingStrategy, SamplingParams
+
+
+@pytest_asyncio.fixture
+async def engine():
+    """创建测试用 LLMEngine 实例"""
+    config = LLMEngineConfig(
+        model_path="sshleifer/tiny-gpt2",  # 使用小模型快速测试
+        backend_type="cpu",
+        max_new_tokens=20,
+    )
+    engine = LLMEngine(config)
+    await engine.start()
+    yield engine
+    await engine.stop()
+
+
+@pytest.mark.asyncio
+async def test_default_greedy_decoding(engine):
+    """测试默认参数使用贪婪解码（temperature=0.0）"""
+    response = await engine.generate("Hello, how are")
+
+    assert response.output_text is not None
+    assert len(response.output_text) > 0
+    assert response.metrics.ttft_ms is not None
+    print(f"✓ 默认贪婪解码输出: {response.output_text[:100]}...")
+
+
+@pytest.mark.asyncio
+async def test_backward_compatible_params(engine):
+    """测试向后兼容的参数传递"""
+    response = await engine.generate("The weather today is", temperature=0.8, top_p=0.9, top_k=50)
+
+    assert response.output_text is not None
+    assert len(response.output_text) > 0
+    print(f"✓ 向后兼容参数输出: {response.output_text[:100]}...")
+
+
+@pytest.mark.asyncio
+async def test_sampling_params_object(engine):
+    """测试使用 SamplingParams 对象（推荐方式）"""
+    params = SamplingParams(
+        strategy=DecodingStrategy.SAMPLING,
+        max_tokens=15,
+        temperature=0.7,
+        top_p=0.9,
+        top_k=40,
+    )
+
+    response = await engine.generate("Once upon a time", sampling_params=params)
+
+    assert response.output_text is not None
+    assert len(response.output_text) > 0
+    print(f"✓ SamplingParams 对象输出: {response.output_text[:100]}...")
+
+
+@pytest.mark.asyncio
+async def test_sampling_params_override(engine):
+    """测试 SamplingParams 覆盖向后兼容参数"""
+    # SamplingParams 应优先于单独参数
+    params = SamplingParams(
+        strategy=DecodingStrategy.GREEDY,
+        temperature=0.0,  # 贪婪解码
+    )
+
+    response = await engine.generate(
+        "Hello",
+        temperature=0.9,  # 这个会被 SamplingParams 覆盖
+        sampling_params=params,
+    )
+
+    assert response.output_text is not None
+    assert len(response.output_text) > 0
+    print(f"✓ 参数优先级测试输出: {response.output_text[:100]}...")
+
+
+@pytest.mark.asyncio
+async def test_reproducible_sampling(engine):
+    """测试使用 seed 的可复现采样"""
+    params = SamplingParams(
+        strategy=DecodingStrategy.SAMPLING,
+        temperature=0.7,
+        top_p=0.9,
+        seed=42,
+        max_tokens=10,
+    )
+
+    response1 = await engine.generate("Hello", sampling_params=params)
+    response2 = await engine.generate("Hello", sampling_params=params)
+
+    # 相同 seed 应产生相同结果
+    assert response1.output_text == response2.output_text
+    print(f"✓ 可复现采样输出: {response1.output_text}")