guidellm 0.1.0__py3-none-any.whl

guidellm/config.py

@@ -0,0 +1,234 @@
+import json
+from enum import Enum
+from typing import Dict, List, Optional, Sequence
+
+from pydantic import BaseModel, Field, model_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+__all__ = [
+    "DatasetSettings",
+    "EmulatedDataSettings",
+    "Environment",
+    "LoggingSettings",
+    "OpenAISettings",
+    "print_config",
+    "ReportGenerationSettings",
+    "Settings",
+    "reload_settings",
+    "settings",
+]
+
+
+class Environment(str, Enum):
+    """
+    Enum for the supported environments
+    """
+
+    LOCAL = "local"
+    DEV = "dev"
+    STAGING = "staging"
+    PROD = "prod"
+
+
+ENV_REPORT_MAPPING = {
+    Environment.PROD: "https://guidellm.neuralmagic.com/local-report/index.html",
+    Environment.STAGING: "https://staging.guidellm.neuralmagic.com/local-report/index.html",
+    Environment.DEV: "https://dev.guidellm.neuralmagic.com/local-report/index.html",
+    Environment.LOCAL: "tests/dummy/report.html",
+}
+
+
+class LoggingSettings(BaseModel):
+    """
+    Logging settings for the application
+    """
+
+    disabled: bool = False
+    clear_loggers: bool = True
+    console_log_level: str = "WARNING"
+    log_file: Optional[str] = None
+    log_file_level: Optional[str] = None
+
+
+class DatasetSettings(BaseModel):
+    """
+    Dataset settings for the application
+    """
+
+    preferred_data_columns: List[str] = Field(
+        default_factory=lambda: [
+            "prompt",
+            "instruction",
+            "input",
+            "inputs",
+            "question",
+            "context",
+            "text",
+            "content",
+            "body",
+            "data",
+        ]
+    )
+    preferred_data_splits: List[str] = Field(
+        default_factory=lambda: ["test", "tst", "validation", "val", "train"]
+    )
+
+
+class EmulatedDataSettings(BaseModel):
+    """
+    Emulated data settings for the application to use
+    """
+
+    source: str = "https://www.gutenberg.org/files/1342/1342-0.txt"
+    filter_start: str = "It is a truth universally acknowledged, that a"
+    filter_end: str = "CHISWICK PRESS:--CHARLES WHITTINGHAM AND CO."
+    clean_text_args: Dict[str, bool] = Field(
+        default_factory=lambda: {
+            "fix_encoding": True,
+            "clean_whitespace": True,
+            "remove_empty_lines": True,
+            "force_new_line_punctuation": True,
+        }
+    )
+
+
+class OpenAISettings(BaseModel):
+    """
+    OpenAI settings for the application to connect to the API
+    for OpenAI server based pathways
+    """
+
+    # OpenAI API key.
+    api_key: str = "invalid_token"
+
+    # OpenAI-compatible server URL
+    # NOTE: The default value is default address of llama.cpp web server
+    base_url: str = "http://localhost:8000/v1"
+
+    max_gen_tokens: int = 4096
+
+
+class ReportGenerationSettings(BaseModel):
+    """
+    Report generation settings for the application
+    """
+
+    source: str = ""
+    report_html_match: str = "window.report_data = {};"
+    report_html_placeholder: str = "{}"
+
+
+class Settings(BaseSettings):
+    """
+    All the settings are powered by pydantic_settings and could be
+    populated from the .env file.
+
+    The format to populate the settings is next
+
+    ```sh
+    export GUIDELLM__LOGGING__DISABLED=true
+    export GUIDELLM__OPENAI__API_KEY=******
+    ```
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="GUIDELLM__",
+        env_nested_delimiter="__",
+        extra="ignore",
+        validate_default=True,
+        env_file=".env",
+    )
+
+    # general settings
+    env: Environment = Environment.PROD
+    request_timeout: int = 30
+    max_concurrency: int = 512
+    num_sweep_profiles: int = 9
+    logging: LoggingSettings = LoggingSettings()
+
+    # Data settings
+    dataset: DatasetSettings = DatasetSettings()
+    emulated_data: EmulatedDataSettings = EmulatedDataSettings()
+
+    # Request settings
+    openai: OpenAISettings = OpenAISettings()
+
+    # Report settings
+    report_generation: ReportGenerationSettings = ReportGenerationSettings()
+
+    @model_validator(mode="after")
+    @classmethod
+    def set_default_source(cls, values):
+        if not values.report_generation.source:
+            values.report_generation.source = ENV_REPORT_MAPPING.get(values.env)
+
+        return values
+
+    def generate_env_file(self) -> str:
+        """
+        Generate the .env file from the current settings
+        """
+        return Settings._recursive_generate_env(
+            self,
+            self.model_config["env_prefix"],  # type: ignore  # noqa: PGH003
+            self.model_config["env_nested_delimiter"],  # type: ignore  # noqa: PGH003
+        )
+
+    @staticmethod
+    def _recursive_generate_env(model: BaseModel, prefix: str, delimiter: str) -> str:
+        env_file = ""
+        add_models = []
+        for key, value in model.model_dump().items():
+            if isinstance(value, BaseModel):
+                # add nested properties to be processed after the current level
+                add_models.append((key, value))
+                continue
+
+            dict_values = (
+                {
+                    f"{prefix}{key.upper()}{delimiter}{sub_key.upper()}": sub_value
+                    for sub_key, sub_value in value.items()
+                }
+                if isinstance(value, dict)
+                else {f"{prefix}{key.upper()}": value}
+            )
+
+            for tag, sub_value in dict_values.items():
+                if isinstance(sub_value, Sequence) and not isinstance(sub_value, str):
+                    value_str = ",".join(f'"{item}"' for item in sub_value)
+                    env_file += f"{tag}=[{value_str}]\n"
+                elif isinstance(sub_value, Dict):
+                    value_str = json.dumps(sub_value)
+                    env_file += f"{tag}={value_str}\n"
+                elif not sub_value:
+                    env_file += f"{tag}=\n"
+                else:
+                    env_file += f'{tag}="{sub_value}"\n'
+
+        for key, value in add_models:
+            env_file += Settings._recursive_generate_env(
+                value, f"{prefix}{key.upper()}{delimiter}", delimiter
+            )
+        return env_file
+
+
+settings = Settings()
+
+
+def reload_settings():
+    """
+    Reload the settings from the environment variables
+    """
+    new_settings = Settings()
+    settings.__dict__.update(new_settings.__dict__)
+
+
+def print_config():
+    """
+    Print the current configuration settings
+    """
+    print(f"Settings: \n{settings.generate_env_file()}")  # noqa: T201
+
+
+if __name__ == "__main__":
+    print_config()

guidellm/core/__init__.py

@@ -0,0 +1,24 @@
+from .distribution import Distribution
+from .report import GuidanceReport
+from .request import TextGenerationRequest
+from .result import (
+    RequestConcurrencyMeasurement,
+    TextGenerationBenchmark,
+    TextGenerationBenchmarkReport,
+    TextGenerationError,
+    TextGenerationResult,
+)
+from .serializable import Serializable, SerializableFileType
+
+__all__ = [
+    "Distribution",
+    "GuidanceReport",
+    "RequestConcurrencyMeasurement",
+    "Serializable",
+    "SerializableFileType",
+    "TextGenerationBenchmark",
+    "TextGenerationBenchmarkReport",
+    "TextGenerationError",
+    "TextGenerationRequest",
+    "TextGenerationResult",
+]

guidellm/core/distribution.py

@@ -0,0 +1,190 @@
+from typing import List, Sequence
+
+import numpy as np
+from loguru import logger
+from pydantic import Field
+
+from guidellm.core.serializable import Serializable
+
+__all__ = ["Distribution"]
+
+
+class Distribution(Serializable):
+    """
+    A class to represent a statistical distribution and perform various
+    statistical analyses.
+    """
+
+    data: Sequence[float] = Field(
+        default_factory=list,
+        description="The data points of the distribution.",
+    )
+
+    def __str__(self):
+        return f"Distribution({self.describe()})"
+
+    def __len__(self):
+        return len(self.data)
+
+    @property
+    def mean(self) -> float:
+        """
+        Calculate and return the mean of the distribution.
+        :return: The mean of the distribution.
+        """
+        if not self.data:
+            logger.warning("No data points available to calculate mean.")
+            return 0.0
+
+        mean_value = np.mean(self.data).item()
+        logger.debug(f"Calculated mean: {mean_value}")
+        return mean_value
+
+    @property
+    def median(self) -> float:
+        """
+        Calculate and return the median of the distribution.
+        :return: The median of the distribution.
+        """
+        if not self.data:
+            logger.warning("No data points available to calculate median.")
+            return 0.0
+
+        median_value = np.median(self.data).item()
+        logger.debug(f"Calculated median: {median_value}")
+        return median_value
+
+    @property
+    def variance(self) -> float:
+        """
+        Calculate and return the variance of the distribution.
+        :return: The variance of the distribution.
+        """
+        if not self.data:
+            logger.warning("No data points available to calculate variance.")
+            return 0.0
+
+        variance_value = np.var(self.data).item()
+        logger.debug(f"Calculated variance: {variance_value}")
+        return variance_value
+
+    @property
+    def std_deviation(self) -> float:
+        """
+        Calculate and return the standard deviation of the distribution.
+        :return: The standard deviation of the distribution.
+        """
+        if not self.data:
+            logger.warning("No data points available to calculate standard deviation.")
+            return 0.0
+
+        std_deviation_value = np.std(self.data).item()
+        logger.debug(f"Calculated standard deviation: {std_deviation_value}")
+        return std_deviation_value
+
+    def percentile(self, percentile: float) -> float:
+        """
+        Calculate and return the specified percentile of the distribution.
+        :param percentile: The desired percentile to calculate (0-100).
+        :return: The specified percentile of the distribution.
+        """
+        if not self.data:
+            logger.warning("No data points available to calculate percentile.")
+            return 0.0
+
+        percentile_value = np.percentile(self.data, percentile).item()
+        logger.debug(f"Calculated {percentile}th percentile: {percentile_value}")
+        return percentile_value
+
+    def percentiles(self, percentiles: List[float]) -> List[float]:
+        """
+        Calculate and return the specified percentiles of the distribution.
+        :param percentiles: A list of desired percentiles to calculate (0-100).
+        :return: A list of the specified percentiles of the distribution.
+        """
+        if not self.data:
+            logger.warning("No data points available to calculate percentiles.")
+            return [0.0] * len(percentiles)
+
+        percentiles_values: List[float] = np.percentile(self.data, percentiles).tolist()  # type: ignore  # noqa: PGH003
+        logger.debug(f"Calculated percentiles {percentiles}: {percentiles_values}")
+        return percentiles_values
+
+    @property
+    def min(self) -> float:
+        """
+        Return the minimum value of the distribution.
+        :return: The minimum value of the distribution.
+        """
+        if not self.data:
+            logger.warning("No data points available to calculate minimum.")
+            return 0.0
+
+        min_value: float = np.min(self.data).item()  # type: ignore  # noqa: PGH003
+        logger.debug(f"Calculated min: {min_value}")
+        return min_value
+
+    @property
+    def max(self) -> float:
+        """
+        Return the maximum value of the distribution.
+        :return: The maximum value of the distribution.
+        """
+        if not self.data:
+            logger.warning("No data points available to calculate maximum.")
+            return 0.0
+
+        max_value: float = np.max(self.data).item()  # type: ignore  # noqa: PGH003
+        logger.debug(f"Calculated max: {max_value}")
+        return max_value
+
+    @property
+    def range(self) -> float:
+        """
+        Calculate and return the range of the distribution (max - min).
+        :return: The range of the distribution.
+        """
+        if not self.data:
+            logger.warning("No data points available to calculate range.")
+            return 0.0
+
+        range_value = self.max - self.min
+        logger.debug(f"Calculated range: {range_value}")
+        return range_value
+
+    def describe(self) -> dict:
+        """
+        Return a dictionary describing various statistics of the distribution.
+        :return: A dictionary with statistical summaries of the distribution.
+        """
+        description = {
+            "mean": self.mean,
+            "median": self.median,
+            "variance": self.variance,
+            "std_deviation": self.std_deviation,
+            "percentile_indices": [10, 20, 30, 40, 50, 60, 70, 80, 90, 95, 99],
+            "percentile_values": self.percentiles(
+                [10, 20, 30, 40, 50, 60, 70, 80, 90, 95, 99],
+            ),
+            "min": self.min,
+            "max": self.max,
+            "range": self.range,
+        }
+        logger.debug(f"Generated description: {description}")
+        return description
+
+    def add_data(self, new_data: Sequence[float]):
+        """
+        Add new data points to the distribution.
+        :param new_data: A list of new numerical data points to add.
+        """
+        self.data = list(self.data) + list(new_data)
+        logger.debug(f"Added new data: {new_data}")
+
+    def remove_data(self, remove_data: Sequence[float]):
+        """
+        Remove specified data points from the distribution.
+        :param remove_data: A list of numerical data points to remove.
+        """
+        self.data = [item for item in self.data if item not in remove_data]
+        logger.debug(f"Removed data: {remove_data}")