PyPI - adaptive-harmony - Versions diffs - 0.1.23__py3-none-any.whl - Mend

adaptive-harmony 0.1.23__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (67) hide show

adaptive_harmony/__init__.py +162 -0
adaptive_harmony/common/__init__.py +40 -0
adaptive_harmony/common/callbacks.py +219 -0
adaptive_harmony/common/checkpointing.py +163 -0
adaptive_harmony/common/dpo.py +92 -0
adaptive_harmony/common/env_grpo.py +361 -0
adaptive_harmony/common/grpo.py +260 -0
adaptive_harmony/common/gspo.py +70 -0
adaptive_harmony/common/ppo.py +303 -0
adaptive_harmony/common/rm.py +79 -0
adaptive_harmony/common/sft.py +121 -0
adaptive_harmony/core/__init__.py +0 -0
adaptive_harmony/core/dataset.py +72 -0
adaptive_harmony/core/display.py +93 -0
adaptive_harmony/core/image_utils.py +110 -0
adaptive_harmony/core/reasoning.py +12 -0
adaptive_harmony/core/reward_client/__init__.py +19 -0
adaptive_harmony/core/reward_client/client.py +160 -0
adaptive_harmony/core/reward_client/reward_types.py +49 -0
adaptive_harmony/core/reward_client/websocket_utils.py +18 -0
adaptive_harmony/core/rich_counter.py +351 -0
adaptive_harmony/core/rl_utils.py +38 -0
adaptive_harmony/core/schedulers.py +38 -0
adaptive_harmony/core/structured_output.py +385 -0
adaptive_harmony/core/utils.py +365 -0
adaptive_harmony/environment/__init__.py +8 -0
adaptive_harmony/environment/environment.py +121 -0
adaptive_harmony/evaluation/__init__.py +1 -0
adaptive_harmony/evaluation/evaluation_artifact.py +67 -0
adaptive_harmony/graders/__init__.py +20 -0
adaptive_harmony/graders/answer_relevancy_judge/__init__.py +3 -0
adaptive_harmony/graders/answer_relevancy_judge/answer_relevancy_judge.py +102 -0
adaptive_harmony/graders/answer_relevancy_judge/prompts.py +58 -0
adaptive_harmony/graders/base_grader.py +265 -0
adaptive_harmony/graders/binary_judge/__init__.py +8 -0
adaptive_harmony/graders/binary_judge/binary_judge.py +202 -0
adaptive_harmony/graders/binary_judge/prompts.py +125 -0
adaptive_harmony/graders/combined_grader.py +118 -0
adaptive_harmony/graders/context_relevancy_judge/__init__.py +3 -0
adaptive_harmony/graders/context_relevancy_judge/context_relevancy_judge.py +128 -0
adaptive_harmony/graders/context_relevancy_judge/prompts.py +84 -0
adaptive_harmony/graders/exceptions.py +9 -0
adaptive_harmony/graders/faithfulness_judge/__init__.py +3 -0
adaptive_harmony/graders/faithfulness_judge/faithfulness_judge.py +159 -0
adaptive_harmony/graders/faithfulness_judge/prompts.py +22 -0
adaptive_harmony/graders/range_judge/__init__.py +7 -0
adaptive_harmony/graders/range_judge/prompts.py +232 -0
adaptive_harmony/graders/range_judge/range_judge.py +188 -0
adaptive_harmony/graders/range_judge/types.py +12 -0
adaptive_harmony/graders/reward_server_grader.py +36 -0
adaptive_harmony/graders/templated_prompt_judge.py +237 -0
adaptive_harmony/graders/utils.py +79 -0
adaptive_harmony/logging_table.py +1 -0
adaptive_harmony/metric_logger.py +452 -0
adaptive_harmony/parameters/__init__.py +2 -0
adaptive_harmony/py.typed +0 -0
adaptive_harmony/runtime/__init__.py +2 -0
adaptive_harmony/runtime/context.py +2 -0
adaptive_harmony/runtime/data.py +2 -0
adaptive_harmony/runtime/decorators.py +2 -0
adaptive_harmony/runtime/model_artifact_save.py +2 -0
adaptive_harmony/runtime/runner.py +27 -0
adaptive_harmony/runtime/simple_notifier.py +2 -0
adaptive_harmony-0.1.23.dist-info/METADATA +37 -0
adaptive_harmony-0.1.23.dist-info/RECORD +67 -0
adaptive_harmony-0.1.23.dist-info/WHEEL +5 -0
adaptive_harmony-0.1.23.dist-info/top_level.txt +1 -0

adaptive_harmony/core/image_utils.py ADDED Viewed

@@ -0,0 +1,110 @@
+import base64
+import html
+import io
+import os
+from PIL import Image
+from adaptive_harmony import StringThread
+def save_inlined_string_to_png(image_str: str, path_to_save: str):
+    _, base64_str = image_str.split(",")
+    image_data = base64.b64decode(base64_str)
+    image = Image.open(io.BytesIO(image_data))
+    image.save(path_to_save)
+def save_string_thread_to_markdown_dir(thread: StringThread, directory_path: str):
+    all_fragments = thread.get_fragments()
+    os.makedirs(directory_path, exist_ok=True)
+    image_counter = 0
+    with open(os.path.join(directory_path, "main.md"), "w") as w:
+        for role, fragments in all_fragments:
+            w.write(f"# {role}\n")
+            for fragment in fragments:
+                if fragment["type"] == "text":
+                    w.write(fragment["text"])
+                else:
+                    assert fragment["type"] == "image"
+                    filename = f"image_{image_counter}.jpeg"
+                    image_path = os.path.join(directory_path, filename)
+                    save_inlined_string_to_png(fragment["url"], image_path)
+                    w.write(f"![image info]({filename})\n")
+def string_thread_to_html_string(thread: StringThread) -> str:
+    """
+    Converts a StringThread into a single, valid HTML string.
+    Text is converted to paragraphs, and images are embedded directly
+    using their base64 data URIs.
+    """
+    html_parts = []
+    all_fragments = thread.get_fragments()
+    for role, fragments in all_fragments:
+        # Use a heading for the role (e.g., 'user', 'model')
+        html_parts.append(f"<h2>{role.capitalize()}</h2>")
+        for fragment in fragments:
+            if fragment["type"] == "text":
+                # Escape HTML special characters. CSS will handle wrapping and newlines.
+                text_content = html.escape(fragment["text"])
+                html_parts.append(f"<p>{text_content}</p>")
+            elif fragment["type"] == "image":
+                # The 'url' is the data URI, which can be used directly in the <img> src
+                image_url = fragment["url"]
+                html_parts.append(
+                    f'<img src="{image_url}" alt="Embedded image content" style="max-width: 500px; height: auto; display: block; margin: 10px 0;">'
+                )
+    # Combine all parts into a single string
+    body_content = "\n".join(html_parts)
+    # Wrap the content in a complete, styled HTML document
+    return f"""
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>StringThread Conversation</title>
+    <style>
+        body {{
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+            line-height: 1.6;
+            color: #000000;
+            margin: 20px auto;
+            padding: 0 20px;
+        }}
+        h2 {{
+            border-bottom: 2px solid #eee;
+            padding-bottom: 10px;
+            margin-top: 40px;
+            margin-left: 40px;
+            width: 600px;
+            color: #000000;
+        }}
+        p {{
+            width: 600px;
+            margin: 16px 0;
+            margin-left: 40px;
+            word-break: break-word; /* Helps with breaking long words if needed */
+            white-space: pre-wrap; /* Preserve newlines and wrap long lines */
+        }}
+        img {{
+            border: 1px solid #ddd;
+            border-radius: 8px;
+            padding: 5px;
+            background-color: #ffffff; /* Changed to white */
+        }}
+    </style>
+</head>
+<body>
+    <div style="background-color: #ffffff; width: 680px;">
+        <h1>Conversation Thread</h1>
+        {body_content}
+    </div>
+</body>
+</html>
+"""

adaptive_harmony/core/reasoning.py ADDED Viewed

@@ -0,0 +1,12 @@
+import re
+def remove_reasoning(completion: str) -> str:
+    """Get the completion without the reasoning.
+    This is a quick implementation for Qwen3 thinking tags only at the moment.
+    """
+    # Remove either <think>...</think> tags or content from start to </think> if <think> is a prefix from the chat template.
+    result = re.sub(r"<think>.*?</think>|^.*?</think>", "", completion, count=1, flags=re.DOTALL)
+    return result.strip()

adaptive_harmony/core/reward_client/__init__.py ADDED Viewed

@@ -0,0 +1,19 @@
+from adaptive_harmony.core.reward_client.client import RewardClient
+from adaptive_harmony.core.reward_client.reward_types import (
+    MetadataValidationResponse,
+    Request,
+    Response,
+    ServerInfo,
+    Turn,
+)
+from adaptive_harmony.core.reward_client.websocket_utils import ResponseAccumulator
+__all__ = [
+    "RewardClient",
+    "Turn",
+    "Request",
+    "Response",
+    "MetadataValidationResponse",
+    "ServerInfo",
+    "ResponseAccumulator",
+]

adaptive_harmony/core/reward_client/client.py ADDED Viewed

@@ -0,0 +1,160 @@
+import asyncio
+import json
+from typing import Any, Final
+import httpx
+from httpx import Limits
+from jsonschema import ValidationError as JsonSchemaValidationError
+from jsonschema import validate
+from loguru import logger
+from websockets.asyncio.client import ClientConnection, connect
+from adaptive_harmony.core.reward_client.reward_types import (
+    MetadataValidationResponse,
+    Request,
+    Response,
+    ServerInfo,
+    Turn,
+)
+from adaptive_harmony.core.reward_client.websocket_utils import ResponseAccumulator
+SCORE_PATH: Final = "/score"
+INFO_PATH: Final = "/info"
+METADATA_SCHEMA_PATH: Final = "/metadata_schema"
+async def read_task(client: ClientConnection, responses: dict[int, Response | asyncio.Event]):
+    response_accumulators: dict[int, ResponseAccumulator] = {}
+    while True:
+        try:
+            msg = await client.recv()
+            obj = json.loads(msg)
+            id = obj["id"]
+            if total_num_chunks := obj.get("total_num_chunks"):
+                assert id not in response_accumulators
+                response_accumulators[id] = ResponseAccumulator(total_num_chunks)
+            else:
+                assert (acc := response_accumulators.get(id))
+                acc.add_chunk(obj["chunk"])
+                if acc.is_complete():
+                    del response_accumulators[id]
+                    response = Response.model_validate_json(acc.get_full_data())  # type: ignore
+                    # sanity check
+                    assert response.id == id
+                    event: asyncio.Event = responses.pop(id)  # type: ignore
+                    responses[id] = response
+                    event.set()
+        except Exception as e:
+            logger.error(f"{e}")
+            break
+class RewardClient:
+    def __init__(self, base_url: str, max_connections: int = 32, timeout: float | None = None):
+        if base_url.startswith("https://"):
+            self.use_secure_protocol = True
+            self.base_url = base_url.removeprefix("https://")
+        else:
+            assert base_url.startswith("http://"), f"Unknown url format {base_url}"
+            self.use_secure_protocol = False
+            self.base_url = base_url.removeprefix("http://")
+        self._client = httpx.AsyncClient(
+            headers=dict(),
+            base_url=self._get_http_url(),
+            timeout=timeout,
+            limits=Limits(max_connections=max_connections),
+        )
+        self._metadata_json_schema: None | dict[str, Any] = None
+        self.use_websocket = False
+        self.max_connections = max_connections
+    def _get_http_url(self):
+        if self.use_secure_protocol:
+            return f"https://{self.base_url}"
+        else:
+            return f"http://{self.base_url}"
+    def _get_ws_url(self):
+        if self.use_secure_protocol:
+            return f"wss://{self.base_url}/ws"
+        else:
+            return f"ws://{self.base_url}/ws"
+    async def setup(self):
+        await self.connect_websocket()
+    async def connect_websocket(self):
+        self.use_websocket = True
+        self.ws_client: ClientConnection = await connect(self._get_ws_url(), ping_timeout=None)
+        self.ws_responses: dict[int, Response | asyncio.Event] = dict()
+        logger.info("Spawning_read_task")
+        self.read_task = asyncio.create_task(read_task(self.ws_client, self.ws_responses))
+        self.request_id = 0
+        # no need to blast 2x more than the amount of workers
+        self.semaphore = asyncio.Semaphore(self.max_connections)
+        return self
+    async def drop_websocket(self):
+        assert self.use_websocket
+        logger.info("Cancelling_read_task")
+        self.read_task.cancel()
+        await self.ws_client.close()
+    async def _post(self, path: str, data: dict) -> httpx.Response:
+        response = await self._client.post(path, json=data)
+        response.raise_for_status()
+        return response
+    async def _ws_post(self, req: Request) -> Response:
+        async with self.semaphore:
+            request_id = self.request_id
+            self.request_id += 1
+            req.id = request_id
+            event = asyncio.Event()
+            self.ws_responses[request_id] = event
+            await self.ws_client.send(req.model_dump_json())
+            await event.wait()
+            response: Response = self.ws_responses.pop(request_id)  # type: ignore
+            assert response.id == request_id
+            return response
+    async def score(self, req: Request) -> Response:
+        if not self.use_websocket:
+            response = await self._post(SCORE_PATH, req.model_dump())
+            return Response(**response.json())
+        else:
+            return await self._ws_post(req)
+    async def validate_metadata(self, metadata: dict[Any, Any]):
+        if self._metadata_json_schema is None:
+            response = await self._client.get(METADATA_SCHEMA_PATH)
+            self._metadata_json_schema = response.json()
+        try:
+            validate(instance=metadata, schema=self._metadata_json_schema)  # type: ignore
+            return MetadataValidationResponse(is_valid=True)
+        except JsonSchemaValidationError as e:
+            return MetadataValidationResponse(is_valid=False, error_message=str(e))
+    async def info(self) -> ServerInfo:
+        response = await self._client.get(INFO_PATH)
+        response.raise_for_status()
+        return ServerInfo(**response.json())
+    def blocking_info(self) -> ServerInfo:
+        return ServerInfo(**httpx.get(self._client.base_url.join(INFO_PATH), timeout=self._client.timeout).json())
+async def main():
+    # client = RewardClient("0.0.0.0:50056")
+    client = await RewardClient("0.0.0.0:50056").connect_websocket()
+    tasks = []
+    for _ in range(1024):
+        task = client.score(Request(turns=[Turn(role="assistant", content="hello")]))
+        tasks.append(task)
+    await asyncio.gather(*tasks)
+if __name__ == "__main__":
+    asyncio.run(main())

adaptive_harmony/core/reward_client/reward_types.py ADDED Viewed

@@ -0,0 +1,49 @@
+from typing import Any, TypeVar
+from pydantic import BaseModel as PydanticBaseModel
+from pydantic import ConfigDict
+class BaseModel(PydanticBaseModel):
+    model_config = ConfigDict(extra="forbid")
+MetadataType = TypeVar("MetadataType", bound=BaseModel)
+class Turn(BaseModel):
+    """@public"""
+    role: str
+    content: str
+class Request(BaseModel):
+    """@public"""
+    turns: list[Turn]
+    metadata: dict[str, Any] | None = None
+    id: int | None = None
+class Response(BaseModel):
+    """@public"""
+    reward: float
+    metadata: dict[str, Any]
+    id: int | None = None
+class MetadataValidationResponse(BaseModel):
+    """@public"""
+    is_valid: bool
+    error_message: str | None = None
+class ServerInfo(BaseModel):
+    """@public"""
+    version: str
+    name: str
+    description: str

adaptive_harmony/core/reward_client/websocket_utils.py ADDED Viewed

@@ -0,0 +1,18 @@
+from dataclasses import dataclass, field
+@dataclass
+class ResponseAccumulator:
+    total_num_chunks: int = 0
+    chunks_received: list[str] = field(default_factory=list)
+    def add_chunk(self, chunk: str):
+        self.chunks_received.append(chunk)
+    def is_complete(self) -> bool:
+        return len(self.chunks_received) == self.total_num_chunks
+    def get_full_data(self) -> str | None:
+        if self.is_complete():
+            return "".join(self.chunks_received)
+        return None