From 34e28e3d0f1a67ce6814ec1a745ad6fd8d5f9817 Mon Sep 17 00:00:00 2001 From: Manuel Bellersen Date: Thu, 7 Aug 2025 16:20:26 +0200 Subject: [PATCH] GH-16: feat(serialize): Add data profiling for dataframes using duckdb This commit introduces a data profiling feature that calculates and stores summary statistics for each column of the serialized dataframes. Key changes: - Added `duckdb` as a new dependency to efficiently query Parquet files. - When a dataframe is serialized to Parquet, `duckdb`'s `SUMMARIZE` function is used to compute statistics (count, min, max, mean, std, quantiles, etc.). - Introduced new Pydantic models in `getml_io.metadata.dataframe_information` to represent column profiles and statistics for various data types and roles (e.g., `ColumnProfile`, `ColumnStatisticsNumerical`, `ColumnStatisticsCategorical`). - The `DataFrameInformation` model is extended to include a `profile` field, which stores a mapping of column names to their respective profiles. - Added a new `UnsupportedStatisticsRoleError` for roles that are not yet supported for profiling. Additionally, the integration test suite has been significantly refactored for better organization and maintainability: - Test data setup and project creation logic have been extracted into modular components under `tests/integration/data/`. - Assertion logic has been enhanced and centralized in `tests/integration/assertions.py`. - Expected test outcomes are now loaded from JSON files, making tests cleaner and easier to manage. --- pyproject.toml | 1 + .../metadata/dataframe_information.py | 127 + src/getml_io/metadata/utils.py | 3 - src/getml_io/serialize/container.py | 18 +- src/getml_io/serialize/dataframe_or_view.py | 126 +- src/getml_io/serialize/exception.py | 20 + src/getml_io/serialize/pipeline.py | 20 +- src/getml_io/utils/convert.py | 4 +- tests/integration/assertions.py | 135 + tests/integration/conftest.py | 623 +- tests/integration/data/__init__.py | 0 tests/integration/data/cora/__init__.py | 0 tests/integration/data/cora/cora.py | 106 + tests/integration/data/datasets.py | 67 + tests/integration/data/getmlproject.py | 266 + tests/integration/data/loans/__init__.py | 0 .../data/loans/expected.container.json | 1053 +++ .../data/loans/expected.pipeline.json | 593 ++ tests/integration/data/loans/loans.py | 90 + tests/integration/data/numerical/__init__.py | 0 .../data/numerical/expected.container.json | 210 + .../data/numerical/expected.pipeline.json | 521 ++ tests/integration/data/numerical/numerical.py | 80 + tests/integration/data/robot/__init__.py | 0 .../data/robot/expected.container.json | 7017 +++++++++++++++++ .../data/robot/expected.pipeline.json | 6841 ++++++++++++++++ tests/integration/data/robot/robot.py | 106 + tests/integration/helpers.py | 32 + tests/integration/test_serialize_cora.py | 2 +- tests/integration/test_serialize_loans.py | 98 +- tests/integration/test_serialize_numerical.py | 89 +- tests/integration/test_serialize_robot.py | 101 +- tests/unit/conftest.py | 184 +- .../metadata/test_container_information.py | 26 + .../metadata/test_pipeline_information.py | 23 + tests/unit/serialize/test_container.py | 107 +- .../unit/serialize/test_dataframe_or_view.py | 130 +- tests/unit/serialize/test_pipeline.py | 25 +- 38 files changed, 17966 insertions(+), 878 deletions(-) create mode 100644 tests/integration/data/__init__.py create mode 100644 tests/integration/data/cora/__init__.py create mode 100644 tests/integration/data/cora/cora.py create mode 100644 tests/integration/data/datasets.py create mode 100644 tests/integration/data/getmlproject.py create mode 100644 tests/integration/data/loans/__init__.py create mode 100644 tests/integration/data/loans/expected.container.json create mode 100644 tests/integration/data/loans/expected.pipeline.json create mode 100644 tests/integration/data/loans/loans.py create mode 100644 tests/integration/data/numerical/__init__.py create mode 100644 tests/integration/data/numerical/expected.container.json create mode 100644 tests/integration/data/numerical/expected.pipeline.json create mode 100644 tests/integration/data/numerical/numerical.py create mode 100644 tests/integration/data/robot/__init__.py create mode 100644 tests/integration/data/robot/expected.container.json create mode 100644 tests/integration/data/robot/expected.pipeline.json create mode 100644 tests/integration/data/robot/robot.py create mode 100644 tests/integration/helpers.py diff --git a/pyproject.toml b/pyproject.toml index 52aeb2c..9041f50 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -39,6 +39,7 @@ dependencies = [ "pydantic~=2.11.4", "pyarrow~=19.0.1", "platformdirs~=4.3.8", + "duckdb~=1.3.2", ] [project.urls] diff --git a/src/getml_io/metadata/dataframe_information.py b/src/getml_io/metadata/dataframe_information.py index c2a02c1..b01bc41 100644 --- a/src/getml_io/metadata/dataframe_information.py +++ b/src/getml_io/metadata/dataframe_information.py @@ -1,11 +1,138 @@ from __future__ import annotations +from collections.abc import Mapping +from datetime import datetime +from enum import Enum from pathlib import Path +from typing import Annotated, Literal, get_args +import getml.data.roles.types as roles +from pydantic import Field, TypeAdapter from pydantic.dataclasses import dataclass +from getml_io.utils.convert import assume_is_str + + +class Role(str, Enum): + CATEGORICAL = assume_is_str(get_args(roles.Categorical)[0]) + JOIN_KEY = assume_is_str(get_args(roles.JoinKey)[0]) + NUMERICAL = assume_is_str(get_args(roles.Numerical)[0]) + TARGET = assume_is_str(get_args(roles.Target)[0]) + TEXT = assume_is_str(get_args(roles.Text)[0]) + TIME_STAMP = assume_is_str(get_args(roles.TimeStamp)[0]) + UNUSED_FLOAT = assume_is_str(get_args(roles.UnusedFloat)[0]) + UNUSED_STRING = assume_is_str(get_args(roles.UnusedString)[0]) + + +@dataclass(frozen=True) +class ColumnStatisticsDouble: + count: int + approx_unique: int + avg: float + min: float + max: float + q25: float + q50: float + q75: float + std: float + null_percentage: float + column_type: Literal["DOUBLE"] + + +@dataclass(frozen=True) +class ColumnStatisticsVarchar: + count: int + approx_unique: int + min: str + max: str + null_percentage: float + column_type: Literal["VARCHAR"] + + +@dataclass(frozen=True) +class ColumnStatisticsNumerical(ColumnStatisticsDouble): + type: Literal["numerical"] = "numerical" + + +@dataclass(frozen=True) +class ColumnStatisticsTarget(ColumnStatisticsDouble): + type: Literal["target"] = "target" + + +@dataclass(frozen=True) +class ColumnStatisticsTimeStamp: + count: int + approx_unique: int + avg: datetime + min: datetime + max: datetime + q25: datetime + q50: datetime + q75: datetime + null_percentage: float + column_type: Literal["TIMESTAMP_NS"] + type: Literal["time_stamp"] = "time_stamp" + + +@dataclass(frozen=True) +class ColumnStatisticsTimeStampAsFloat(ColumnStatisticsDouble): + type: Literal["time_stamp_float"] = "time_stamp_float" + + +@dataclass(frozen=True) +class ColumnStatisticsCategorical(ColumnStatisticsVarchar): + type: Literal["categorical"] = "categorical" + + +@dataclass(frozen=True) +class ColumnStatisticsJoinKey(ColumnStatisticsVarchar): + type: Literal["join_key"] = "join_key" + + +@dataclass(frozen=True) +class ColumnStatisticsUnusedFloat(ColumnStatisticsDouble): + type: Literal["unused_float"] = "unused_float" + + +@dataclass(frozen=True) +class ColumnStatisticsUnusedString(ColumnStatisticsVarchar): + type: Literal["unused_string"] = "unused_string" + + +ColumnStatistics = Annotated[ + ColumnStatisticsNumerical + | ColumnStatisticsTarget + | ColumnStatisticsCategorical + | ColumnStatisticsJoinKey + | ColumnStatisticsTimeStamp + | ColumnStatisticsTimeStampAsFloat + | ColumnStatisticsUnusedFloat + | ColumnStatisticsUnusedString, + Field(discriminator="type"), +] + + +@dataclass +class ColumnProfile: + name: str + role: Role + statistics: ColumnStatistics + @dataclass class DataFrameInformation: name: str path: Path + profile: Mapping[str, ColumnProfile] + + +ROLE_TYPE_ADAPTER_MAPPING = { + (Role.CATEGORICAL, "VARCHAR"): TypeAdapter(ColumnStatisticsCategorical), + (Role.JOIN_KEY, "VARCHAR"): TypeAdapter(ColumnStatisticsJoinKey), + (Role.NUMERICAL, "DOUBLE"): TypeAdapter(ColumnStatisticsNumerical), + (Role.TARGET, "DOUBLE"): TypeAdapter(ColumnStatisticsTarget), + (Role.TIME_STAMP, "TIMESTAMP_NS"): TypeAdapter(ColumnStatisticsTimeStamp), + (Role.TIME_STAMP, "DOUBLE"): TypeAdapter(ColumnStatisticsTimeStampAsFloat), + (Role.UNUSED_FLOAT, "DOUBLE"): TypeAdapter(ColumnStatisticsUnusedFloat), + (Role.UNUSED_STRING, "VARCHAR"): TypeAdapter(ColumnStatisticsUnusedString), +} diff --git a/src/getml_io/metadata/utils.py b/src/getml_io/metadata/utils.py index f150096..ff55e6d 100644 --- a/src/getml_io/metadata/utils.py +++ b/src/getml_io/metadata/utils.py @@ -3,12 +3,9 @@ from pathlib import Path from typing import Protocol, TypeVar -from pydantic.dataclasses import dataclass - from getml_io.metadata.exception import PathNotRelativeError -@dataclass class InstanceProtocol(Protocol): name: str path: Path diff --git a/src/getml_io/serialize/container.py b/src/getml_io/serialize/container.py index c206408..c2e576b 100644 --- a/src/getml_io/serialize/container.py +++ b/src/getml_io/serialize/container.py @@ -42,17 +42,19 @@ def serialize_container( container, container_storage_directory, ) + peripheral_information = serialize_peripheral( + container, + container_storage_directory, + ) + subsets_information = serialize_subsets( + container, + container_storage_directory, + ) container_information = ContainerInformation( id=assume_is_str(container.id), population=population_information, - peripheral=serialize_peripheral( - container, - container_storage_directory, - ), - subsets=serialize_subsets( - container, - container_storage_directory, - ), + peripheral=peripheral_information, + subsets=subsets_information, deep_copy=assume_is_bool(container.deep_copy), path=target_storage_directory, ) diff --git a/src/getml_io/serialize/dataframe_or_view.py b/src/getml_io/serialize/dataframe_or_view.py index 8fc0d8d..e885549 100644 --- a/src/getml_io/serialize/dataframe_or_view.py +++ b/src/getml_io/serialize/dataframe_or_view.py @@ -1,19 +1,40 @@ from __future__ import annotations +import logging +from logging import Logger from pathlib import Path +import duckdb from getml.data import ( DataFrame, View, ) +from pydantic import TypeAdapter -from getml_io.metadata.dataframe_information import DataFrameInformation +from getml_io.metadata.dataframe_information import ( + ROLE_TYPE_ADAPTER_MAPPING, + ColumnProfile, + ColumnStatistics, + ColumnStatisticsCategorical, + ColumnStatisticsJoinKey, + ColumnStatisticsNumerical, + ColumnStatisticsTarget, + ColumnStatisticsTimeStamp, + ColumnStatisticsTimeStampAsFloat, + ColumnStatisticsUnusedFloat, + ColumnStatisticsUnusedString, + DataFrameInformation, + Role, +) from getml_io.serialize.exception import ( DataFrameParquetStorageError, + UnsupportedColumnStatisticsError, ) from getml_io.utils.convert import assume_is_str from getml_io.utils.exception import StorageDirectoryCreationError +logger: Logger = logging.getLogger(__name__) + def serialize_dataframe_or_view( dataframe_or_view: DataFrame | View, @@ -53,16 +74,111 @@ def serialize_dataframe_or_view( if filename_prefix and filename_prefix != name else name ) - filepath = target_storage_directory / f"{filename}.parquet" + parquet_filepath = target_storage_directory / f"{filename}.parquet" try: - dataframe_or_view.to_parquet(str(filepath)) + dataframe_or_view.to_parquet(str(parquet_filepath)) except Exception as exception: raise DataFrameParquetStorageError( name, - filepath, + parquet_filepath, ) from exception + profile = _calculate_profile(parquet_filepath, dataframe_or_view) + return DataFrameInformation( name=name, - path=filepath, + path=parquet_filepath, + profile=profile, + ) + + +def _calculate_profile( + parquet_filepath: Path, + dataframe_or_view: DataFrame | View, +) -> dict[str, ColumnProfile]: + summary_statistics = _calculate_summary_statistics( + parquet_filepath, + dataframe_or_view, + ) + return { + name: ColumnProfile( + name=name, + role=Role(dataframe_or_view.roles.column(name)), + statistics=summary_statistics[name], + ) + for name in dataframe_or_view.columns + } + + +def _calculate_summary_statistics( + parquet_filepath: Path, + dataframe_or_view: DataFrame | View, +) -> dict[str, ColumnStatistics]: + raw_summary_statistics = _fetch_raw_summary_statistics(parquet_filepath) + return _build_column_statistics( + dataframe_or_view, + raw_summary_statistics, ) + + +SUMMARIZE_STATEMENT_TEMPLATE = "SUMMARIZE (SELECT * FROM read_parquet(?))" + + +def _fetch_raw_summary_statistics( + parquet_filepath: Path, +) -> dict[str, dict[str, str | int | float]]: + with ( + duckdb.connect() as connection, + ): + logger.debug( + "Calculating summary statistics for Parquet '%s'", + parquet_filepath, + ) + return ( + connection.execute(SUMMARIZE_STATEMENT_TEMPLATE, [str(parquet_filepath)]) + .df() + .set_index("column_name") + .to_dict(orient="index") + ) + + +def _build_column_statistics( + dataframe_or_view: DataFrame | View, + raw_summary_statistics: dict[str, dict[str, str | int | float]], +) -> dict[str, ColumnStatistics]: + return { + name: _get_column_statistics_adapter( + dataframe_or_view, + name, + assume_is_str(raw_summary_statistics[name]["column_type"]), + ).validate_python( + raw_summary_statistics[name], + ) + for name in dataframe_or_view.columns + } + + +def _get_column_statistics_adapter( + dataframe_or_view: DataFrame | View, + name: str, + column_type: str, +) -> ( + TypeAdapter[ColumnStatisticsNumerical] + | TypeAdapter[ColumnStatisticsTarget] + | TypeAdapter[ColumnStatisticsCategorical] + | TypeAdapter[ColumnStatisticsJoinKey] + | TypeAdapter[ColumnStatisticsTimeStamp] + | TypeAdapter[ColumnStatisticsTimeStampAsFloat] + | TypeAdapter[ColumnStatisticsUnusedFloat] + | TypeAdapter[ColumnStatisticsUnusedString] +): + role = Role(assume_is_str(dataframe_or_view.roles.column(name))) + adapter = ROLE_TYPE_ADAPTER_MAPPING.get((role, column_type)) + if adapter is None: + raise UnsupportedColumnStatisticsError( + assume_is_str(dataframe_or_view.name), + name, + role, + column_type, + ) + return adapter diff --git a/src/getml_io/serialize/exception.py b/src/getml_io/serialize/exception.py index 74a6b89..ecae607 100644 --- a/src/getml_io/serialize/exception.py +++ b/src/getml_io/serialize/exception.py @@ -1,5 +1,6 @@ from pathlib import Path +from getml_io.metadata.dataframe_information import ROLE_TYPE_ADAPTER_MAPPING, Role from getml_io.utils.exception import GetMLIOError @@ -76,3 +77,22 @@ class TableParquetStorageError(GetMLIOStorageError): def __init__(self, name: str, path: Path) -> None: """Initialize the exception with a custom message.""" super().__init__("Table as parquet", name, path) + + +class UnsupportedColumnStatisticsError(GetMLIOError): + """Exception raised when an unsupported column statistics is encountered.""" + + def __init__( + self, + dataframe_name: str, + column_name: str, + role: Role, + column_type: str, + ) -> None: + """Initialize the exception with a custom message.""" + message = ( + f"Column {column_name!r} in dataframe {dataframe_name!r} has an " + f"unsupported role: {role!r} and type: {column_type}. " + f"Supported are: {list(ROLE_TYPE_ADAPTER_MAPPING.keys())}." + ) + super().__init__(message) diff --git a/src/getml_io/serialize/pipeline.py b/src/getml_io/serialize/pipeline.py index 202dc17..3af9ab3 100644 --- a/src/getml_io/serialize/pipeline.py +++ b/src/getml_io/serialize/pipeline.py @@ -82,15 +82,15 @@ def serialize_predictions( """ predict_storage_directory = target_storage_directory / "predictions" prediction_results = PredictionResults() - for name in assume_is_dict_str_to_dataframe_or_view(container.subsets): - prediction = pipeline.predict(container[name]) + for subset_name in assume_is_dict_str_to_dataframe_or_view(container.subsets): + prediction = pipeline.predict(container[subset_name]) path = serialize_ndarray( array=cast("NDArray[np.float64]", prediction), target_storage_directory=predict_storage_directory, - name=name, + name=subset_name, ) - prediction_results[name] = TableInformation( - name=name, + prediction_results[subset_name] = TableInformation( + name=subset_name, path=path, ) @@ -117,15 +117,15 @@ def serialize_feature_sets( """ transform_storage_directory = target_storage_directory / "feature_sets" feature_sets = FeatureSets() - for name in assume_is_dict_str_to_dataframe_or_view(container.subsets): + for subset_name in assume_is_dict_str_to_dataframe_or_view(container.subsets): features = pipeline.transform( - container[name], - df_name=f"features.{name}", + container[subset_name], + df_name=f"features.{subset_name}", ) dataframe_information = serialize_dataframe_or_view( - cast("DataFrame", cast("object", features)), + cast("DataFrame", features), transform_storage_directory, ) - feature_sets[name] = dataframe_information + feature_sets[subset_name] = dataframe_information return feature_sets diff --git a/src/getml_io/utils/convert.py b/src/getml_io/utils/convert.py index baa24d6..ade46b4 100644 --- a/src/getml_io/utils/convert.py +++ b/src/getml_io/utils/convert.py @@ -11,7 +11,9 @@ from getml.data.columns import FloatColumn, StringColumn -def assume_is_str(value: FloatColumn | StringColumn | str | Subset) -> str: +def assume_is_str( + value: FloatColumn | StringColumn | str | Subset | float, +) -> str: """Assume `value` conforms to the return type for static analysis. Args: diff --git a/tests/integration/assertions.py b/tests/integration/assertions.py index d7b06ae..b07dea6 100644 --- a/tests/integration/assertions.py +++ b/tests/integration/assertions.py @@ -1,5 +1,14 @@ from pathlib import Path +from getml_io.metadata.container_information import ContainerInformation +from getml_io.metadata.dataframe_information import ( + ColumnProfile, + ColumnStatistics, + DataFrameInformation, +) +from getml_io.metadata.pipeline_information import PipelineInformation +from getml_io.metadata.table_information import TableInformation + def assert_container_parquets( container_directory: Path, @@ -41,3 +50,129 @@ def assert_files_in_directory( assert directory.is_dir() available_filenames = {file.name for file in directory.iterdir() if file.is_file()} assert available_filenames == set(expected_files) + + +def assert_container_information( + container_information: ContainerInformation, + expected_container_information: ContainerInformation, +) -> None: + assert container_information.id + assert container_information.deep_copy == expected_container_information.deep_copy + assert container_information.path == expected_container_information.path + + assert_dataframe_information( + container_information.population, + expected_container_information.population, + ) + + assert ( + container_information.peripheral.keys() + == expected_container_information.peripheral.keys() + ) + for ( + peripheral_name, + peripheral_entry, + ) in expected_container_information.peripheral.items(): + assert_dataframe_information( + container_information.peripheral[peripheral_name], + peripheral_entry, + ) + + assert ( + container_information.subsets.keys() + == expected_container_information.subsets.keys() + ) + for subset_name, subset_entry in expected_container_information.subsets.items(): + assert_dataframe_information( + container_information.subsets[subset_name], + subset_entry, + ) + + +def assert_dataframe_information( + dataframe_information: DataFrameInformation | None, + expected_dataframe_information: DataFrameInformation | None, +) -> None: + if dataframe_information is None and expected_dataframe_information is None: + return + + assert dataframe_information is not None + assert expected_dataframe_information is not None + + assert dataframe_information.name == expected_dataframe_information.name + assert dataframe_information.path == expected_dataframe_information.path + + assert ( + dataframe_information.profile.keys() + == expected_dataframe_information.profile.keys() + ) + for column_name, column_profile in expected_dataframe_information.profile.items(): + assert_column_profile( + dataframe_information.profile[column_name], + column_profile, + ) + + +def assert_column_profile( + column_profile: ColumnProfile, + expected_column_profile: ColumnProfile, +) -> None: + assert column_profile.name == expected_column_profile.name + assert column_profile.role == expected_column_profile.role + assert_column_statistics( + column_profile.statistics, + expected_column_profile.statistics, + ) + + +def assert_column_statistics( + column_statistics: ColumnStatistics, + expected_column_statistics: ColumnStatistics, +) -> None: + assert column_statistics.column_type == expected_column_statistics.column_type + assert column_statistics.type == expected_column_statistics.type + assert column_statistics.count == expected_column_statistics.count + # Other keys ("approx_unique", "avg", "max", "min", "q25", "q50", "q75", "std", + # "null_percentage") are not checked here because they can vary between test runs + # due to the nature of the underlying data and the serialization process. + + +def assert_pipeline_information( + pipeline_information: PipelineInformation, + expected_pipeline_information: PipelineInformation, +) -> None: + assert pipeline_information.id + assert pipeline_information.path == expected_pipeline_information.path + + assert ( + pipeline_information.feature_sets.keys() + == expected_pipeline_information.feature_sets.keys() + ) + for ( + feature_set_name, + feature_set, + ) in expected_pipeline_information.feature_sets.items(): + assert_dataframe_information( + pipeline_information.feature_sets[feature_set_name], + feature_set, + ) + assert ( + pipeline_information.predictions.keys() + == expected_pipeline_information.predictions.keys() + ) + for ( + prediction_name, + prediction, + ) in expected_pipeline_information.predictions.items(): + assert_table_information( + pipeline_information.predictions[prediction_name], + prediction, + ) + + +def assert_table_information( + table_information: TableInformation, + expected_table_information: TableInformation, +) -> None: + assert table_information.name == expected_table_information.name + assert table_information.path == expected_table_information.path diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py index 5267223..239e4d5 100644 --- a/tests/integration/conftest.py +++ b/tests/integration/conftest.py @@ -1,97 +1,35 @@ from __future__ import annotations import hashlib -import logging import re -from abc import ABC -from collections.abc import Callable, Generator -from contextlib import contextmanager -from enum import Enum +from collections.abc import Generator from pathlib import Path -from typing import TypeVar, cast +from typing import cast -import getml import platformdirs import pytest -from filelock import FileLock -from getml.data import Container, DataFrame, DataModel, TimeSeries, View -from getml.data.columns import StringColumnView -from getml.feature_learning import Multirel, Relboost, RelMT -from getml.feature_learning.loss_functions import CrossEntropyLoss, SquareLoss -from getml.pipeline import Pipeline -from getml.predictors import ( - XGBoostClassifier, - XGBoostRegressor, -) -from pydantic import ConfigDict -from pydantic.dataclasses import dataclass from getml_io.getml.getml import alive_getml -from getml_io.utils.convert import ( - assume_is_dict_str_to_dataframe_or_view, +from tests.integration.data.cora.cora import ( + CoraProject, + CoraProjectFactory, ) - -logger: logging.Logger = logging.getLogger(__name__) -DATA_PATH: Path = Path(__file__).parent / "data" - - -class DataSetName(str, Enum): - ROBOT = "robot" - LOANS = "loans" - CORA = "cora" - NUMERICAL = "numerical" - - -@dataclass -class DataSet: - name: DataSetName - population: list[Path] - peripheral: list[Path] +from tests.integration.data.datasets import DATA_PATH +from tests.integration.data.getmlproject import getml_project +from tests.integration.data.loans.loans import ( + LoansProject, + LoansProjectFactory, +) +from tests.integration.data.numerical.numerical import ( + NumericalProject, + NumericalProjectFactory, +) +from tests.integration.data.robot.robot import RobotProject, RobotProjectFactory -DATASETS: dict[DataSetName, DataSet] = { - DataSetName.ROBOT: DataSet( - name=DataSetName.ROBOT, - population=[ - DATA_PATH / "robot/container/population/full.parquet", - ], - peripheral=[], - ), - DataSetName.LOANS: DataSet( - name=DataSetName.LOANS, - population=[ - DATA_PATH / "loans/container/population/test.parquet", - DATA_PATH / "loans/container/population/train.parquet", - ], - peripheral=[ - DATA_PATH / "loans/container/peripheral/meta.parquet", - DATA_PATH / "loans/container/peripheral/order.parquet", - DATA_PATH / "loans/container/peripheral/trans.parquet", - ], - ), - DataSetName.CORA: DataSet( - name=DataSetName.CORA, - population=[ - DATA_PATH / "cora/container/population/test.parquet", - DATA_PATH / "cora/container/population/train.parquet", - ], - peripheral=[ - DATA_PATH / "cora/container/peripheral/cites.parquet", - DATA_PATH / "cora/container/peripheral/content.parquet", - DATA_PATH / "cora/container/peripheral/paper.parquet", - ], - ), - DataSetName.NUMERICAL: DataSet( - name=DataSetName.NUMERICAL, - population=[ - DATA_PATH / "numerical/container/population/train.parquet", - DATA_PATH / "numerical/container/population/test.parquet", - ], - peripheral=[ - DATA_PATH / "numerical/container/peripheral/perph.parquet", - ], - ), -} +@pytest.fixture(scope="session") +def data_path() -> Path: + return DATA_PATH @pytest.fixture @@ -124,324 +62,6 @@ def session_cache_dir() -> Path: ) -class GetMLProjectBundle: - def __init__( - self, - project_name: str, - session_cache_dir: Path, - dataset_name: DataSetName, - ) -> None: - self._project_name: str = project_name - self._session_cache_dir: Path = session_cache_dir - self._dataset_name: DataSetName = dataset_name - self._filename: str = f"{dataset_name}.getml" - self._path: Path = session_cache_dir / self._filename - - @property - def path(self) -> Path: - return self._path - - @property - def name(self) -> str: - return self._project_name - - def set_project(self) -> None: - if self._project_name in getml.engine.list_projects(): - logger.warning( - ( - "Project %r already exists in the getML engine. " - "This indicates that a previous test failed to clean up properly. " - "Deleting the project and reloading it." - ), - self._project_name, - ) - getml.engine.delete_project(self._project_name) - - if self._is_bundle_older_than_dataset(): - self._path.unlink(missing_ok=True) - - self._load_project() - - def save_bundle( - self, - ) -> None: - if not self._path.exists(): - self._save_project_bundle() - - def _load_project(self) -> None: - if self._path.exists(): - logger.info( - "Loading project %r from bundle %r...", - self._project_name, - str(self._path), - ) - getml.project.load( - bundle=str(self._path), - name=self._project_name, - ) - else: - logger.info("Creating project %r...", self._project_name) - getml.engine.set_project(self._project_name) - - def _is_bundle_older_than_dataset(self) -> bool: - dataset = DATASETS[self._dataset_name] - population_paths = dataset.population - peripheral_paths = dataset.peripheral - - if not self._path.exists(): - return True - - bundle_mtime = self._path.stat().st_mtime - - for path in population_paths + peripheral_paths: - if path.exists() and path.stat().st_mtime > bundle_mtime: - return True - - return False - - def _save_project_bundle(self) -> None: - dataframe_names = { - name for names in getml.data.list_data_frames().values() for name in names - } - logger.info("Saving project dataframes %s...", dataframe_names) - getml.project.data_frames.save() - - logger.info( - "Saving project %r to bundle %r...", - self._project_name, - str(self._path), - ) - getml.project.save(filename=self._path) - - -@contextmanager -def getml_project_bundle( - project_bundle: GetMLProjectBundle, -) -> Generator[GetMLProjectBundle]: - with FileLock(project_bundle.path.with_suffix(".lock")) as lock: - logger.info( - "Acquired lock for project bundle %r at %s with lock file %s", - project_bundle.name, - project_bundle.path, - lock.lock_file, - ) - try: - project_bundle.set_project() - yield project_bundle - - except Exception: - logger.exception( - "An error occurred while using project bundle %r: %s", - project_bundle.name, - project_bundle.path, - ) - raise - finally: - project_bundle.save_bundle() - - logger.info( - "Releasing lock for project bundle %r at %s with lock file %s", - project_bundle.name, - project_bundle.path, - lock.lock_file, - ) - - -@dataclass(config=ConfigDict(arbitrary_types_allowed=True)) -class GetMLProject: - name: str - pipeline: Pipeline - container: Container - - def delete(self) -> None: - logger.info("Deleting project %r...", self.name) - getml.engine.delete_project(self.name) - - -class GetMLProjectFactory(ABC): # noqa: B024 - def _load_dataframes_from_parquet( - self, - dataset_paths: list[Path], - ) -> dict[str, DataFrame | View]: - logger.info("Loading dataframes from parquet files %r...", dataset_paths) - dataframes: dict[str, DataFrame | View] = {} - for dataset_path in dataset_paths: - if not dataset_path.exists(): - message = f"Dataset {dataset_path!r} does not exist." - raise FileNotFoundError(message) - - if dataset_path.suffix != ".parquet": - message = f"Dataset {dataset_path!r} is not a parquet file." - raise ValueError(message) - - dataframe = DataFrame.from_parquet( - str(dataset_path), - name=dataset_path.stem, - ) - dataframes[dataset_path.stem] = dataframe.save() - - return dataframes - - def _load_container_from_parquet_dataset( - self, - dataset_name: DataSetName, - ) -> Container: - logger.info("Loading container from parquet dataset %r...", dataset_name.value) - dataset = DATASETS[dataset_name] - - population = self._load_dataframes_from_parquet(dataset.population) - peripheral = self._load_dataframes_from_parquet(dataset.peripheral) - - container = Container( - **population, - peripheral=peripheral, - split=None, - deep_copy=False, - ) - container._id = dataset_name.value # noqa: SLF001 # pyright: ignore[reportPrivateUsage] - container.save() - return container - - def _load_getml_container(self, dataset_name: DataSetName) -> Container: - try: - return getml.data.load_container(dataset_name.value) - except OSError as exception: - logger.info( - ( - "Container %r not found in getml engine. " - "Reason: %s " - "Loading from parquet dataset instead." - ), - dataset_name.value, - exception, - ) - return self._load_container_from_parquet_dataset(dataset_name) - - def _ensure_fitted_pipeline( - self, - pipeline_factory: Callable[[], Pipeline], - container: Container, - ) -> Pipeline: - if pipelines := getml.pipeline.list_pipelines(): - logger.info( - "Found existing pipelines in getml engine: %r Loading first one: %r.", - pipelines, - pipelines[0], - ) - fitted_pipeline = getml.pipeline.load(pipelines[0]) - else: - logger.info("Creating new pipeline...") - pipeline = pipeline_factory() - fitted_pipeline = self._train_pipeline(pipeline, container) - - return fitted_pipeline - - def _train_pipeline(self, pipeline: Pipeline, container: Container) -> Pipeline: - logger.info("Fitting pipeline...") - fitted_pipeline: Pipeline = pipeline.fit(container.train) - - logger.info("Scoring pipeline on test...") - _ = fitted_pipeline.score(container.test) - - if hasattr(container, "validation"): - logger.info("Scoring pipeline on validation...") - _ = fitted_pipeline.score(container.validation) - - return fitted_pipeline - - -GetMLProjectType = TypeVar("GetMLProjectType", bound="GetMLProject") - - -@contextmanager -def getml_project(project: GetMLProjectType) -> Generator[GetMLProjectType]: - try: - yield project - except Exception: - logger.exception("An error occurred while using project %r", project.name) - raise - finally: - project.delete() - - -@dataclass -class RobotProject(GetMLProject): - pass - - -class RobotProjectFactory(GetMLProjectFactory): - def create( - self, - project_name: str, - session_cache_dir: Path, - ) -> RobotProject: - dataset_name: DataSetName = DataSetName.ROBOT - with getml_project_bundle( - GetMLProjectBundle( - project_name, - session_cache_dir, - dataset_name, - ), - ) as project_bundle: - name: str = project_bundle.name - dataframe: DataFrame = self._get_dataframe(dataset_name) - split: StringColumnView = self._get_split(dataframe) - timeseries: TimeSeries = self._get_timeseries( - dataframe, - split, - ) - container: Container = timeseries.container - pipeline: Pipeline = self._ensure_fitted_pipeline( - lambda: self._create_pipeline(timeseries), - container, - ) - container.save() - return RobotProject(name, pipeline, container) - - def _get_dataframe(self, dataset_name: DataSetName) -> DataFrame: - container = self._load_getml_container(dataset_name) - return cast("DataFrame", container.full.population) - - def _get_split(self, dataframe: DataFrame) -> StringColumnView: - num_entries: int = len(dataframe) - test_start = int(num_entries * 0.6) - validation_start = int(num_entries * 0.8) - return getml.data.split.time( - dataframe, - "rowid", - test=test_start, - validation=validation_start, - ) - - def _get_timeseries( - self, - dataframe: DataFrame, - split: StringColumnView, - ) -> TimeSeries: - return getml.data.TimeSeries( - population=dataframe, - split=split, - time_stamps="rowid", - lagged_targets=False, - memory=30, - ) - - def _create_pipeline(self, timeseries: TimeSeries) -> Pipeline: - relboost: Relboost = Relboost( - loss_function=SquareLoss, - num_features=10, - ) - - xgboost_regressor: XGBoostRegressor = XGBoostRegressor() - - logger.info("Robot: Creating pipeline...") - return Pipeline( - data_model=timeseries.data_model, - feature_learners=[relboost], - predictors=[xgboost_regressor], - ) - - @pytest.fixture def robot_project( getml_backend: None, @@ -459,73 +79,6 @@ def robot_project( yield project -@dataclass -class LoansProject(GetMLProject): - pass - - -class LoansProjectFactory(GetMLProjectFactory): - def create( - self, - project_name: str, - session_cache_dir: Path, - ) -> LoansProject: - dataset_name: DataSetName = DataSetName.LOANS - with getml_project_bundle( - GetMLProjectBundle( - project_name, - session_cache_dir, - dataset_name, - ), - ) as project_bundle: - name: str = project_bundle.name - container = self._load_getml_container(dataset_name) - data_model = self._get_data_model(container) - pipeline = self._ensure_fitted_pipeline( - lambda: self._create_pipeline(data_model), - container, - ) - return LoansProject( - name=name, - pipeline=pipeline, - container=container, - ) - - def _get_data_model(self, container: Container) -> DataModel: - population_subsets = cast( - "dict[str, DataFrame]", - cast("object", container.subsets), - ) - peripheral_dataframes = cast( - "dict[str, DataFrame]", - cast("object", container.peripheral), - ) - - population_ph = population_subsets["train"].to_placeholder("population") - peripheral_phs = [ - dataframe.to_placeholder() for dataframe in peripheral_dataframes.values() - ] - - data_model = DataModel(population=population_ph) - data_model.add(*peripheral_phs) - data_model.population.join( - data_model.trans, - on="account_id", - time_stamps=("date_loan", "date"), - ) - data_model.population.join(data_model.order, on="account_id") - data_model.population.join(data_model.meta, on="account_id") - return data_model - - def _create_pipeline(self, data_model: DataModel) -> Pipeline: - return Pipeline( - data_model=data_model, - feature_learners=[Multirel(num_features=10)], - predictors=[XGBoostClassifier()], - loss_function=CrossEntropyLoss, - ) - - @pytest.fixture def loans_project( getml_backend: None, @@ -543,89 +96,6 @@ def loans_project( yield project -@dataclass -class CoraProject(GetMLProject): - pass - - -class CoraProjectFactory(GetMLProjectFactory): - def create( - self, - project_name: str, - session_cache_dir: Path, - ) -> CoraProject: - dataset_name: DataSetName = DataSetName.CORA - with getml_project_bundle( - GetMLProjectBundle( - project_name, - session_cache_dir, - dataset_name, - ), - ) as project_bundle: - name: str = project_bundle.name - container = self._load_getml_container(dataset_name) - data_model = self._get_data_model() - pipeline = self._ensure_fitted_pipeline( - lambda: self._create_pipeline(data_model), - container, - ) - return CoraProject( - name=name, - pipeline=pipeline, - container=container, - ) - - def _get_data_model(self) -> DataModel: - population = getml.data.Placeholder("population") - paper = getml.data.Placeholder("paper") - cited = getml.data.Placeholder("cites") - citing = getml.data.Placeholder("cites") - content = getml.data.Placeholder("content") - - population.join( - cited, - on=("paper_id", "cited_paper_id"), - ) - cited.join( - content, - on=("citing_paper_id", "paper_id"), - relationship="propositionalization", - ) - cited.join( - paper, - on=("cited_paper_id", "paper_id"), - relationship="propositionalization", - ) - population.join( - citing, - on=("paper_id", "citing_paper_id"), - ) - citing.join( - content, - on=("cited_paper_id", "paper_id"), - relationship="propositionalization", - ) - citing.join( - paper, - on=("citing_paper_id", "paper_id"), - relationship="propositionalization", - ) - population.join( - content, - on="paper_id", - ) - - return DataModel(population=population) - - def _create_pipeline(self, data_model: DataModel) -> Pipeline: - return Pipeline( - data_model=data_model, - feature_learners=[Relboost(num_features=10)], - predictors=[XGBoostClassifier()], - loss_function=CrossEntropyLoss, - ) - - @pytest.fixture def cora_project( getml_backend: None, @@ -643,61 +113,6 @@ def cora_project( yield project -@dataclass -class NumericalProject(GetMLProject): - pass - - -class NumericalProjectFactory(GetMLProjectFactory): - def create( - self, - project_name: str, - session_cache_dir: Path, - ) -> NumericalProject: - dataset_name: DataSetName = DataSetName.NUMERICAL - with getml_project_bundle( - GetMLProjectBundle( - project_name, - session_cache_dir, - dataset_name, - ), - ) as project_bundle: - name: str = project_bundle.name - container = self._load_getml_container(dataset_name) - data_model = self._get_data_model(container) - pipeline = self._ensure_fitted_pipeline( - lambda: self._create_pipeline(data_model), - container, - ) - return NumericalProject( - name=name, - pipeline=pipeline, - container=container, - ) - - def _get_data_model(self, container: Container) -> DataModel: - train = assume_is_dict_str_to_dataframe_or_view(container.subsets)["train"] - population = train.to_placeholder("population") - perph = assume_is_dict_str_to_dataframe_or_view(container.peripheral)["perph"] - peripheral = perph.to_placeholder("perph") - data_model = DataModel(population=population) - data_model.add(peripheral) - data_model.population.join( - data_model.perph, - on="join_key", - time_stamps="time_stamp", - ) - return data_model - - def _create_pipeline(self, data_model: DataModel) -> Pipeline: - return Pipeline( - data_model=data_model, - feature_learners=[RelMT(num_features=10)], - predictors=[XGBoostRegressor()], - loss_function=SquareLoss, - ) - - @pytest.fixture def numerical_project( getml_backend: None, diff --git a/tests/integration/data/__init__.py b/tests/integration/data/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/integration/data/cora/__init__.py b/tests/integration/data/cora/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/integration/data/cora/cora.py b/tests/integration/data/cora/cora.py new file mode 100644 index 0000000..5f3d0e0 --- /dev/null +++ b/tests/integration/data/cora/cora.py @@ -0,0 +1,106 @@ +from __future__ import annotations + +from pathlib import Path + +import getml +from getml.data import DataModel +from getml.feature_learning import Relboost +from getml.feature_learning.loss_functions import CrossEntropyLoss +from getml.pipeline import Pipeline +from getml.predictors import ( + XGBoostClassifier, +) +from pydantic.dataclasses import dataclass +from typing_extensions import override + +from tests.integration.data.datasets import DataSetName +from tests.integration.data.getmlproject import ( + GetMLProject, + GetMLProjectBundle, + GetMLProjectFactory, + getml_project_bundle, +) + + +@dataclass +class CoraProject(GetMLProject): + pass + + +class CoraProjectFactory(GetMLProjectFactory): + @override + def create( + self, + project_name: str, + session_cache_dir: Path, + ) -> CoraProject: + dataset_name: DataSetName = DataSetName.CORA + with getml_project_bundle( + GetMLProjectBundle( + project_name, + session_cache_dir, + dataset_name, + ), + ) as project_bundle: + name: str = project_bundle.name + container = self._load_getml_container(dataset_name) + data_model = self._get_data_model() + pipeline = self._ensure_fitted_pipeline( + lambda: self._create_pipeline(data_model), + container, + ) + return CoraProject( + name=name, + pipeline=pipeline, + container=container, + ) + + def _get_data_model(self) -> DataModel: + population = getml.data.Placeholder("population") + paper = getml.data.Placeholder("paper") + cited = getml.data.Placeholder("cites") + citing = getml.data.Placeholder("cites") + content = getml.data.Placeholder("content") + + population.join( + cited, + on=("paper_id", "cited_paper_id"), + ) + cited.join( + content, + on=("citing_paper_id", "paper_id"), + relationship="propositionalization", + ) + cited.join( + paper, + on=("cited_paper_id", "paper_id"), + relationship="propositionalization", + ) + population.join( + citing, + on=("paper_id", "citing_paper_id"), + ) + citing.join( + content, + on=("cited_paper_id", "paper_id"), + relationship="propositionalization", + ) + citing.join( + paper, + on=("citing_paper_id", "paper_id"), + relationship="propositionalization", + ) + population.join( + content, + on="paper_id", + ) + + return DataModel(population=population) + + def _create_pipeline(self, data_model: DataModel) -> Pipeline: + return Pipeline( + data_model=data_model, + feature_learners=[Relboost(num_features=10)], + predictors=[XGBoostClassifier()], + loss_function=CrossEntropyLoss, + ) diff --git a/tests/integration/data/datasets.py b/tests/integration/data/datasets.py new file mode 100644 index 0000000..5e3852b --- /dev/null +++ b/tests/integration/data/datasets.py @@ -0,0 +1,67 @@ +from __future__ import annotations + +from enum import Enum +from pathlib import Path + +from pydantic.dataclasses import dataclass + +DATA_PATH: Path = Path(__file__).parent + + +class DataSetName(str, Enum): + ROBOT = "robot" + LOANS = "loans" + CORA = "cora" + NUMERICAL = "numerical" + + +@dataclass +class DataSet: + name: DataSetName + population: list[Path] + peripheral: list[Path] + + +DATASETS: dict[DataSetName, DataSet] = { + DataSetName.ROBOT: DataSet( + name=DataSetName.ROBOT, + population=[ + DATA_PATH / "robot/container/population/full.parquet", + ], + peripheral=[], + ), + DataSetName.LOANS: DataSet( + name=DataSetName.LOANS, + population=[ + DATA_PATH / "loans/container/population/test.parquet", + DATA_PATH / "loans/container/population/train.parquet", + ], + peripheral=[ + DATA_PATH / "loans/container/peripheral/meta.parquet", + DATA_PATH / "loans/container/peripheral/order.parquet", + DATA_PATH / "loans/container/peripheral/trans.parquet", + ], + ), + DataSetName.CORA: DataSet( + name=DataSetName.CORA, + population=[ + DATA_PATH / "cora/container/population/test.parquet", + DATA_PATH / "cora/container/population/train.parquet", + ], + peripheral=[ + DATA_PATH / "cora/container/peripheral/cites.parquet", + DATA_PATH / "cora/container/peripheral/content.parquet", + DATA_PATH / "cora/container/peripheral/paper.parquet", + ], + ), + DataSetName.NUMERICAL: DataSet( + name=DataSetName.NUMERICAL, + population=[ + DATA_PATH / "numerical/container/population/train.parquet", + DATA_PATH / "numerical/container/population/test.parquet", + ], + peripheral=[ + DATA_PATH / "numerical/container/peripheral/perph.parquet", + ], + ), +} diff --git a/tests/integration/data/getmlproject.py b/tests/integration/data/getmlproject.py new file mode 100644 index 0000000..8958cf8 --- /dev/null +++ b/tests/integration/data/getmlproject.py @@ -0,0 +1,266 @@ +from __future__ import annotations + +import logging +from abc import ABC, abstractmethod +from collections.abc import Callable, Generator +from contextlib import contextmanager +from pathlib import Path +from typing import TypeVar + +import getml +from filelock import FileLock +from getml.data import Container, DataFrame, View +from getml.pipeline import Pipeline +from pydantic import ConfigDict +from pydantic.dataclasses import dataclass + +from tests.integration.data.datasets import DATASETS, DataSetName + +logger: logging.Logger = logging.getLogger(__name__) + + +class GetMLProjectBundle: + def __init__( + self, + project_name: str, + session_cache_dir: Path, + dataset_name: DataSetName, + ) -> None: + self._project_name: str = project_name + self._session_cache_dir: Path = session_cache_dir + self._dataset_name: DataSetName = dataset_name + self._filename: str = f"{dataset_name}.getml" + self._path: Path = session_cache_dir / self._filename + + @property + def path(self) -> Path: + return self._path + + @property + def name(self) -> str: + return self._project_name + + def set_project(self) -> None: + if self._project_name in getml.engine.list_projects(): + logger.warning( + ( + "Project %r already exists in the getML engine. " + "This indicates that a previous test failed to clean up properly. " + "Deleting the project and reloading it." + ), + self._project_name, + ) + getml.engine.delete_project(self._project_name) + + if self._is_bundle_older_than_dataset(): + self._path.unlink(missing_ok=True) + + self._load_project() + + def save_bundle( + self, + ) -> None: + if not self._path.exists(): + self._save_project_bundle() + + def _load_project(self) -> None: + if self._path.exists(): + logger.info( + "Loading project %r from bundle %r...", + self._project_name, + str(self._path), + ) + getml.project.load( + bundle=str(self._path), + name=self._project_name, + ) + else: + logger.info("Creating project %r...", self._project_name) + getml.engine.set_project(self._project_name) + + def _is_bundle_older_than_dataset(self) -> bool: + dataset = DATASETS[self._dataset_name] + population_paths = dataset.population + peripheral_paths = dataset.peripheral + + if not self._path.exists(): + return True + + bundle_mtime = self._path.stat().st_mtime + + for path in population_paths + peripheral_paths: + if path.exists() and path.stat().st_mtime > bundle_mtime: + return True + + return False + + def _save_project_bundle(self) -> None: + dataframe_names = { + name for names in getml.data.list_data_frames().values() for name in names + } + logger.info("Saving project dataframes %s...", dataframe_names) + getml.project.data_frames.save() + + logger.info( + "Saving project %r to bundle %r...", + self._project_name, + str(self._path), + ) + getml.project.save(filename=self._path) + + +@dataclass(config=ConfigDict(arbitrary_types_allowed=True)) +class GetMLProject: + name: str + pipeline: Pipeline + container: Container + + def delete(self) -> None: + logger.info("Deleting project %r...", self.name) + getml.engine.delete_project(self.name) + + +class GetMLProjectFactory(ABC): + @abstractmethod + def create( + self, + project_name: str, + session_cache_dir: Path, + ) -> GetMLProject: ... + + def _load_dataframes_from_parquet( + self, + dataset_paths: list[Path], + ) -> dict[str, DataFrame | View]: + logger.info("Loading dataframes from parquet files %r...", dataset_paths) + dataframes: dict[str, DataFrame | View] = {} + for dataset_path in dataset_paths: + if not dataset_path.exists(): + message = f"Dataset {dataset_path!r} does not exist." + raise FileNotFoundError(message) + + if dataset_path.suffix != ".parquet": + message = f"Dataset {dataset_path!r} is not a parquet file." + raise ValueError(message) + + dataframe = DataFrame.from_parquet( + str(dataset_path), + name=dataset_path.stem, + ) + dataframes[dataset_path.stem] = dataframe.save() + + return dataframes + + def _load_container_from_parquet_dataset( + self, + dataset_name: DataSetName, + ) -> Container: + logger.info("Loading container from parquet dataset %r...", dataset_name.value) + dataset = DATASETS[dataset_name] + + population = self._load_dataframes_from_parquet(dataset.population) + peripheral = self._load_dataframes_from_parquet(dataset.peripheral) + + container = Container( + **population, + peripheral=peripheral, + split=None, + deep_copy=False, + ) + container._id = dataset_name.value # noqa: SLF001 # pyright: ignore[reportPrivateUsage] + container.save() + return container + + def _load_getml_container(self, dataset_name: DataSetName) -> Container: + try: + return getml.data.load_container(dataset_name.value) + except OSError as exception: + logger.info( + ( + "Container %r not found in getml engine. " + "Reason: %s " + "Loading from parquet dataset instead." + ), + dataset_name.value, + exception, + ) + return self._load_container_from_parquet_dataset(dataset_name) + + def _ensure_fitted_pipeline( + self, + pipeline_factory: Callable[[], Pipeline], + container: Container, + ) -> Pipeline: + if pipelines := getml.pipeline.list_pipelines(): + logger.info( + "Found existing pipelines in getml engine: %r Loading first one: %r.", + pipelines, + pipelines[0], + ) + fitted_pipeline = getml.pipeline.load(pipelines[0]) + else: + logger.info("Creating new pipeline...") + pipeline = pipeline_factory() + fitted_pipeline = self._train_pipeline(pipeline, container) + + return fitted_pipeline + + def _train_pipeline(self, pipeline: Pipeline, container: Container) -> Pipeline: + logger.info("Fitting pipeline...") + fitted_pipeline: Pipeline = pipeline.fit(container.train) + + logger.info("Scoring pipeline on test...") + _ = fitted_pipeline.score(container.test) + + if hasattr(container, "validation"): + logger.info("Scoring pipeline on validation...") + _ = fitted_pipeline.score(container.validation) + + return fitted_pipeline + + +GetMLProjectType = TypeVar("GetMLProjectType", bound="GetMLProject") + + +@contextmanager +def getml_project_bundle( + project_bundle: GetMLProjectBundle, +) -> Generator[GetMLProjectBundle]: + with FileLock(project_bundle.path.with_suffix(".lock")) as lock: + logger.info( + "Acquired lock for project bundle %r at %s with lock file %s", + project_bundle.name, + project_bundle.path, + lock.lock_file, + ) + try: + project_bundle.set_project() + yield project_bundle + + except Exception: + logger.exception( + "An error occurred while using project bundle %r: %s", + project_bundle.name, + project_bundle.path, + ) + raise + finally: + project_bundle.save_bundle() + + logger.info( + "Releasing lock for project bundle %r at %s with lock file %s", + project_bundle.name, + project_bundle.path, + lock.lock_file, + ) + + +@contextmanager +def getml_project(project: GetMLProjectType) -> Generator[GetMLProjectType]: + try: + yield project + except Exception: + logger.exception("An error occurred while using project %r", project.name) + raise + finally: + project.delete() diff --git a/tests/integration/data/loans/__init__.py b/tests/integration/data/loans/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/integration/data/loans/expected.container.json b/tests/integration/data/loans/expected.container.json new file mode 100644 index 0000000..a312459 --- /dev/null +++ b/tests/integration/data/loans/expected.container.json @@ -0,0 +1,1053 @@ +{ + "id": "loans", + "population": null, + "peripheral": { + "meta": { + "name": "meta", + "path": "container/peripheral/meta.parquet", + "profile": { + "account_id": { + "name": "account_id", + "role": "join_key", + "statistics": { + "count": 5369, + "approx_unique": 5066, + "min": "1", + "max": "998", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "join_key" + } + }, + "type_disp": { + "name": "type_disp", + "role": "categorical", + "statistics": { + "count": 5369, + "approx_unique": 2, + "min": "DISPONENT", + "max": "OWNER", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "categorical" + } + }, + "type_card": { + "name": "type_card", + "role": "categorical", + "statistics": { + "count": 5369, + "approx_unique": 3, + "min": "classic", + "max": "junior", + "null_percentage": 83.39, + "column_type": "VARCHAR", + "type": "categorical" + } + }, + "gender": { + "name": "gender", + "role": "categorical", + "statistics": { + "count": 5369, + "approx_unique": 2, + "min": "F", + "max": "M", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "categorical" + } + }, + "A3": { + "name": "A3", + "role": "categorical", + "statistics": { + "count": 5369, + "approx_unique": 9, + "min": "Prague", + "max": "west Bohemia", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "categorical" + } + }, + "A4": { + "name": "A4", + "role": "numerical", + "statistics": { + "count": 5369, + "approx_unique": 79, + "avg": 269280.5768299497, + "min": 42821.0, + "max": 1204953.0, + "q25": 88835.62784545346, + "q50": 121731.60655567948, + "q75": 216691.32504584195, + "std": 359049.9579979095, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "A5": { + "name": "A5", + "role": "numerical", + "statistics": { + "count": 5369, + "approx_unique": 63, + "avg": 39.63084373253865, + "min": 0.0, + "max": 151.0, + "q25": 7.078362846642164, + "q50": 33.61154098360655, + "q75": 64.49356995884773, + "std": 34.46270131201155, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "A6": { + "name": "A6", + "role": "numerical", + "statistics": { + "count": 5369, + "approx_unique": 37, + "avg": 20.739616315887503, + "min": 0.0, + "max": 70.0, + "q25": 9.629416005767842, + "q50": 20.868444846292945, + "q75": 29.877683097831948, + "std": 15.19045743046103, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "A7": { + "name": "A7", + "role": "numerical", + "statistics": { + "count": 5369, + "approx_unique": 17, + "avg": 5.483143974669399, + "min": 0.0, + "max": 20.0, + "q25": 2.0, + "q50": 5.0, + "q75": 7.293478260869565, + "std": 4.369372568361806, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "A8": { + "name": "A8", + "role": "numerical", + "statistics": { + "count": 5369, + "approx_unique": 6, + "avg": 1.7090705904265227, + "min": 0.0, + "max": 5.0, + "q25": 1.0, + "q50": 1.0, + "q75": 2.0, + "std": 1.0755347561077684, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "A9": { + "name": "A9", + "role": "numerical", + "statistics": { + "count": 5369, + "approx_unique": 12, + "avg": 5.517973551871857, + "min": 1.0, + "max": 11.0, + "q25": 4.0, + "q50": 6.0, + "q75": 7.732613277133824, + "std": 2.940686488794897, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "A10": { + "name": "A10", + "role": "numerical", + "statistics": { + "count": 5369, + "approx_unique": 80, + "avg": 69.24004470106249, + "min": 33.9, + "max": 100.0, + "q25": 52.684124163089166, + "q50": 62.92133952254643, + "q75": 86.1788154579191, + "std": 19.89687014526991, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "A11": { + "name": "A11", + "role": "numerical", + "statistics": { + "count": 5369, + "approx_unique": 74, + "avg": 9510.758614267088, + "min": 8110.0, + "max": 12541.0, + "q25": 8547.157863355776, + "q50": 8982.192406798244, + "q75": 9906.167452830188, + "std": 1330.6866892869507, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "A12": { + "name": "A12", + "role": "numerical", + "statistics": { + "count": 5369, + "approx_unique": 46, + "avg": 2.815617935192228, + "min": 0.2, + "max": 7.3, + "q25": 1.5380291005291005, + "q50": 2.6270239837856098, + "q75": 3.8, + "std": 1.8532588987821759, + "null_percentage": 1.14, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "A13": { + "name": "A13", + "role": "numerical", + "statistics": { + "count": 5369, + "approx_unique": 74, + "avg": 3.4909424473831527, + "min": 0.43, + "max": 9.4, + "q25": 1.9530903670196362, + "q50": 3.4409666725825265, + "q75": 4.774310613654079, + "std": 2.134923983576773, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "A14": { + "name": "A14", + "role": "numerical", + "statistics": { + "count": 5369, + "approx_unique": 53, + "avg": 121.19109703855466, + "min": 81.0, + "max": 167.0, + "q25": 105.09803600654666, + "q50": 116.06593406593407, + "q75": 131.42361111111114, + "std": 23.10652103119667, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "A15": { + "name": "A15", + "role": "numerical", + "statistics": { + "count": 5369, + "approx_unique": 63, + "avg": 14818.629615674454, + "min": 818.0, + "max": 85677.0, + "q25": 2169.118427462853, + "q50": 3731.2140820123313, + "q75": 6811.764622700536, + "std": 27094.330501210123, + "null_percentage": 1.14, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "A16": { + "name": "A16", + "role": "numerical", + "statistics": { + "count": 5369, + "approx_unique": 74, + "avg": 16352.240081951946, + "min": 888.0, + "max": 99107.0, + "q25": 2269.3516307692303, + "q50": 3788.6844835069446, + "q75": 6526.069575143936, + "std": 31330.146615960137, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "disp_id": { + "name": "disp_id", + "role": "unused_float", + "statistics": { + "count": 5369, + "approx_unique": 5645, + "avg": 3337.0979698267834, + "min": 1.0, + "max": 13690.0, + "q25": 1416.0998280360532, + "q50": 2838.684645957939, + "q75": 4256.743404118404, + "std": 2770.4188259897883, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "unused_float" + } + }, + "client_id": { + "name": "client_id", + "role": "unused_float", + "statistics": { + "count": 5369, + "approx_unique": 5875, + "avg": 3359.0119202831065, + "min": 1.0, + "max": 13998.0, + "q25": 1416.0998280360532, + "q50": 2838.684645957939, + "q75": 4256.743404118404, + "std": 2832.911983935477, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "unused_float" + } + }, + "card_id": { + "name": "card_id", + "role": "unused_float", + "statistics": { + "count": 5369, + "approx_unique": 878, + "avg": 480.85538116591925, + "min": 1.0, + "max": 1247.0, + "q25": 229.25206611570246, + "q50": 456.5, + "q75": 684.9197530864199, + "std": 306.933982351379, + "null_percentage": 83.39, + "column_type": "DOUBLE", + "type": "unused_float" + } + }, + "district_id": { + "name": "district_id", + "role": "unused_float", + "statistics": { + "count": 5369, + "approx_unique": 92, + "avg": 37.31011361519836, + "min": 1.0, + "max": 77.0, + "q25": 13.818470722573931, + "q50": 38.406987011507354, + "q75": 59.92210806697107, + "std": 25.04369006808468, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "unused_float" + } + }, + "issued": { + "name": "issued", + "role": "unused_string", + "statistics": { + "count": 5369, + "approx_unique": 505, + "min": "1993-11-07", + "max": "1998-12-29", + "null_percentage": 83.39, + "column_type": "VARCHAR", + "type": "unused_string" + } + }, + "birth_date": { + "name": "birth_date", + "role": "unused_string", + "statistics": { + "count": 5369, + "approx_unique": 5428, + "min": "1911-08-20", + "max": "1987-09-27", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "unused_string" + } + }, + "A2": { + "name": "A2", + "role": "unused_string", + "statistics": { + "count": 5369, + "approx_unique": 81, + "min": "Benesov", + "max": "Znojmo", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "unused_string" + } + } + } + }, + "order": { + "name": "order", + "path": "container/peripheral/order.parquet", + "profile": { + "account_id": { + "name": "account_id", + "role": "join_key", + "statistics": { + "count": 6471, + "approx_unique": 4045, + "min": "1", + "max": "998", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "join_key" + } + }, + "bank_to": { + "name": "bank_to", + "role": "categorical", + "statistics": { + "count": 6471, + "approx_unique": 13, + "min": "AB", + "max": "YZ", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "categorical" + } + }, + "k_symbol": { + "name": "k_symbol", + "role": "categorical", + "statistics": { + "count": 6471, + "approx_unique": 4, + "min": "LEASING", + "max": "UVER", + "null_percentage": 21.31, + "column_type": "VARCHAR", + "type": "categorical" + } + }, + "amount": { + "name": "amount", + "role": "numerical", + "statistics": { + "count": 6471, + "approx_unique": 5364, + "avg": 3280.635697728329, + "min": 1.0, + "max": 14882.0, + "q25": 1239.1918308702795, + "q50": 2587.140182335065, + "q75": 4628.737386363638, + "std": 2714.4753347688775, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "account_to": { + "name": "account_to", + "role": "unused_float", + "statistics": { + "count": 6471, + "approx_unique": 4791, + "avg": 49399036.8511822, + "min": 399.0, + "max": 99994199.0, + "q25": 24064266.526442997, + "q50": 49815670.99575001, + "q75": 73902638.81925167, + "std": 28883559.113534097, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "unused_float" + } + }, + "order_id": { + "name": "order_id", + "role": "unused_float", + "statistics": { + "count": 6471, + "approx_unique": 5314, + "avg": 33778.197496522946, + "min": 29401.0, + "max": 46338.0, + "q25": 31188.06009279533, + "q50": 32986.100754596664, + "q75": 34782.80578852521, + "std": 3737.681948564408, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "unused_float" + } + } + } + }, + "trans": { + "name": "trans", + "path": "container/peripheral/trans.parquet", + "profile": { + "date": { + "name": "date", + "role": "time_stamp", + "statistics": { + "count": 1056320, + "approx_unique": 2059, + "avg": "1997-01-04T07:29:27.037261", + "min": "1993-01-01T00:00:00", + "max": "1998-12-31T00:00:00", + "q25": "1996-01-19T12:28:10.924819", + "q50": "1997-04-11T14:39:25.032342", + "q75": "1998-02-22T10:23:55.488780", + "std": null, + "null_percentage": 0.0, + "column_type": "TIMESTAMP_NS", + "type": "time_stamp" + } + }, + "account_id": { + "name": "account_id", + "role": "join_key", + "statistics": { + "count": 1056320, + "approx_unique": 5066, + "min": "1", + "max": "998", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "join_key" + } + }, + "type": { + "name": "type", + "role": "categorical", + "statistics": { + "count": 1056320, + "approx_unique": 3, + "min": "PRIJEM", + "max": "VYDAJ", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "categorical" + } + }, + "k_symbol": { + "name": "k_symbol", + "role": "categorical", + "statistics": { + "count": 1056320, + "approx_unique": 9, + "min": " ", + "max": "UVER", + "null_percentage": 45.62, + "column_type": "VARCHAR", + "type": "categorical" + } + }, + "bank": { + "name": "bank", + "role": "categorical", + "statistics": { + "count": 1056320, + "approx_unique": 13, + "min": "AB", + "max": "YZ", + "null_percentage": 74.11, + "column_type": "VARCHAR", + "type": "categorical" + } + }, + "operation": { + "name": "operation", + "role": "categorical", + "statistics": { + "count": 1056320, + "approx_unique": 5, + "min": "PREVOD NA UCET", + "max": "VYBER KARTOU", + "null_percentage": 17.34, + "column_type": "VARCHAR", + "type": "categorical" + } + }, + "amount": { + "name": "amount", + "role": "numerical", + "statistics": { + "count": 1056320, + "approx_unique": 31851, + "avg": 5924.210653021812, + "min": 0.0, + "max": 87400.0, + "q25": 138.30929835180666, + "q50": 2093.642401010784, + "q75": 6808.988855970187, + "std": 9522.698103965486, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "balance": { + "name": "balance", + "role": "numerical", + "statistics": { + "count": 1056320, + "approx_unique": 123512, + "avg": 38518.379134163886, + "min": -41126.0, + "max": 209637.0, + "q25": 22404.467808067766, + "q50": 33144.76142873372, + "q75": 49577.534033880554, + "std": 22117.869672220324, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "trans_id": { + "name": "trans_id", + "role": "unused_float", + "statistics": { + "count": 1056320, + "approx_unique": 750752, + "avg": 1335310.7043301272, + "min": 1.0, + "max": 3682987.0, + "q25": 430088.7219779061, + "q50": 859008.6456717633, + "q75": 2089374.764408263, + "std": 1227486.5083824086, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "unused_float" + } + }, + "account": { + "name": "account", + "role": "unused_float", + "statistics": { + "count": 1056320, + "approx_unique": 6723, + "avg": 45670919.374915786, + "min": 0.0, + "max": 99994199.0, + "q25": 17824114.65149773, + "q50": 45543228.53911832, + "q75": 72066905.93096541, + "std": 30663396.851202432, + "null_percentage": 72.04, + "column_type": "DOUBLE", + "type": "unused_float" + } + } + } + } + }, + "subsets": { + "train": { + "name": "train", + "path": "container/subsets/train.parquet", + "profile": { + "date_loan": { + "name": "date_loan", + "role": "time_stamp", + "statistics": { + "count": 459, + "approx_unique": 441, + "avg": "1996-09-03T01:46:40", + "min": "1993-07-05T00:00:00", + "max": "1998-12-08T00:00:00", + "q25": "1995-05-25T08:40:00", + "q50": "1997-01-05T09:18:22.040816", + "q75": "1997-12-03T08:40:00", + "std": null, + "null_percentage": 0.0, + "column_type": "TIMESTAMP_NS", + "type": "time_stamp" + } + }, + "account_id": { + "name": "account_id", + "role": "join_key", + "statistics": { + "count": 459, + "approx_unique": 526, + "min": "10001", + "max": "9928", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "join_key" + } + }, + "default": { + "name": "default", + "role": "target", + "statistics": { + "count": 459, + "approx_unique": 2, + "avg": 0.11982570806100218, + "min": 0.0, + "max": 1.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.3251119594076471, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "frequency": { + "name": "frequency", + "role": "categorical", + "statistics": { + "count": 459, + "approx_unique": 3, + "min": "POPLATEK MESICNE", + "max": "POPLATEK TYDNE", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "categorical" + } + }, + "duration": { + "name": "duration", + "role": "numerical", + "statistics": { + "count": 459, + "approx_unique": 5, + "avg": 37.12418300653595, + "min": 12.0, + "max": 60.0, + "q25": 24.0, + "q50": 36.0, + "q75": 48.0, + "std": 16.81208246952378, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "payments": { + "name": "payments", + "role": "numerical", + "statistics": { + "count": 459, + "approx_unique": 585, + "avg": 4185.23311546841, + "min": 312.0, + "max": 9910.0, + "q25": 2375.409722222222, + "q50": 3976.8571428571427, + "q75": 5883.611111111112, + "std": 2268.721641494734, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "amount": { + "name": "amount", + "role": "numerical", + "statistics": { + "count": 459, + "approx_unique": 535, + "avg": 154961.38562091504, + "min": 4980.0, + "max": 590820.0, + "q25": 67434.16666666667, + "q50": 121004.81632653062, + "q75": 216506.33333333334, + "std": 116425.1930214991, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "loan_id": { + "name": "loan_id", + "role": "unused_float", + "statistics": { + "count": 459, + "approx_unique": 375, + "avg": 6203.398692810458, + "min": 4959.0, + "max": 7305.0, + "q25": 5613.847222222223, + "q50": 6222.551020408164, + "q75": 6809.395833333332, + "std": 688.2930789504136, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "unused_float" + } + }, + "district_id": { + "name": "district_id", + "role": "unused_float", + "statistics": { + "count": 459, + "approx_unique": 92, + "avg": 35.98039215686274, + "min": 1.0, + "max": 77.0, + "q25": 11.777777777777777, + "q50": 37.48979591836735, + "q75": 57.916666666666664, + "std": 24.94022651332247, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "unused_float" + } + }, + "date_account": { + "name": "date_account", + "role": "unused_string", + "statistics": { + "count": 459, + "approx_unique": 441, + "min": "1993-01-13", + "max": "1997-12-22", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "unused_string" + } + }, + "status": { + "name": "status", + "role": "unused_string", + "statistics": { + "count": 459, + "approx_unique": 4, + "min": "A", + "max": "D", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "unused_string" + } + } + } + }, + "test": { + "name": "test", + "path": "container/subsets/test.parquet", + "profile": { + "date_loan": { + "name": "date_loan", + "role": "time_stamp", + "statistics": { + "count": 223, + "approx_unique": 182, + "avg": "1996-11-22T01:49:46.547085", + "min": "1993-11-10T00:00:00", + "max": "1998-12-06T00:00:00", + "q25": "1995-11-23T07:20:00", + "q50": "1997-04-28T16:00:00", + "q75": "1998-01-15T20:00:00", + "std": null, + "null_percentage": 0.0, + "column_type": "TIMESTAMP_NS", + "type": "time_stamp" + } + }, + "account_id": { + "name": "account_id", + "role": "join_key", + "statistics": { + "count": 223, + "approx_unique": 203, + "min": "10005", + "max": "993", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "join_key" + } + }, + "default": { + "name": "default", + "role": "target", + "statistics": { + "count": 223, + "approx_unique": 2, + "avg": 0.09417040358744394, + "min": 0.0, + "max": 1.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.29272270742877293, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "frequency": { + "name": "frequency", + "role": "categorical", + "statistics": { + "count": 223, + "approx_unique": 3, + "min": "POPLATEK MESICNE", + "max": "POPLATEK TYDNE", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "categorical" + } + }, + "duration": { + "name": "duration", + "role": "numerical", + "statistics": { + "count": 223, + "approx_unique": 5, + "avg": 35.19282511210762, + "min": 12.0, + "max": 60.0, + "q25": 24.0, + "q50": 36.0, + "q75": 48.0, + "std": 17.571310118488245, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "payments": { + "name": "payments", + "role": "numerical", + "statistics": { + "count": 223, + "approx_unique": 214, + "avg": 4201.8430493273545, + "min": 304.0, + "max": 9721.0, + "q25": 2527.722222222222, + "q50": 3888.6666666666665, + "q75": 5700.5, + "std": 2107.7211804113517, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "amount": { + "name": "amount", + "role": "numerical", + "statistics": { + "count": 223, + "approx_unique": 223, + "avg": 144100.73542600896, + "min": 10944.0, + "max": 566640.0, + "q25": 62054.0, + "q50": 108992.0, + "q75": 198987.0, + "std": 106696.63113384871, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "loan_id": { + "name": "loan_id", + "role": "unused_float", + "statistics": { + "count": 223, + "approx_unique": 163, + "avg": 6108.798206278027, + "min": 4961.0, + "max": 7308.0, + "q25": 5512.138888888888, + "q50": 6077.666666666667, + "q75": 6683.388888888888, + "std": 667.6850147454904, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "unused_float" + } + }, + "district_id": { + "name": "district_id", + "role": "unused_float", + "statistics": { + "count": 223, + "approx_unique": 75, + "avg": 40.596412556053814, + "min": 1.0, + "max": 77.0, + "q25": 17.5, + "q50": 46.333333333333336, + "q75": 63.86111111111111, + "std": 25.45475381096384, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "unused_float" + } + }, + "date_account": { + "name": "date_account", + "role": "unused_string", + "statistics": { + "count": 223, + "approx_unique": 216, + "min": "1993-01-17", + "max": "1997-12-13", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "unused_string" + } + }, + "status": { + "name": "status", + "role": "unused_string", + "statistics": { + "count": 223, + "approx_unique": 4, + "min": "A", + "max": "D", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "unused_string" + } + } + } + } + }, + "deep_copy": false +} \ No newline at end of file diff --git a/tests/integration/data/loans/expected.pipeline.json b/tests/integration/data/loans/expected.pipeline.json new file mode 100644 index 0000000..fc34029 --- /dev/null +++ b/tests/integration/data/loans/expected.pipeline.json @@ -0,0 +1,593 @@ +{ + "id": "3a4bkF", + "predictions": { + "train": { + "name": "train", + "path": "pipeline/predictions/train.parquet" + }, + "test": { + "name": "test", + "path": "pipeline/predictions/test.parquet" + } + }, + "feature_sets": { + "train": { + "name": "features.train", + "path": "pipeline/feature_sets/features.train.parquet", + "profile": { + "date_loan": { + "name": "date_loan", + "role": "time_stamp", + "statistics": { + "count": 459, + "approx_unique": 441, + "avg": "1996-09-03T01:46:40", + "min": "1993-07-05T00:00:00", + "max": "1998-12-08T00:00:00", + "q25": "1995-05-25T08:40:00", + "q50": "1997-01-05T09:18:22.040816", + "q75": "1997-12-03T08:40:00", + "std": null, + "null_percentage": 0.0, + "column_type": "TIMESTAMP_NS", + "type": "time_stamp" + } + }, + "account_id": { + "name": "account_id", + "role": "join_key", + "statistics": { + "count": 459, + "approx_unique": 526, + "min": "10001", + "max": "9928", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "join_key" + } + }, + "default": { + "name": "default", + "role": "target", + "statistics": { + "count": 459, + "approx_unique": 2, + "avg": 0.11982570806100218, + "min": 0.0, + "max": 1.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.3251119594076471, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "feature_1_1": { + "name": "feature_1_1", + "role": "numerical", + "statistics": { + "count": 459, + "approx_unique": 42, + "avg": 760.5141612200435, + "min": 0.0, + "max": 19621.0, + "q25": 0.0, + "q50": 0.0, + "q75": 202.7777777777778, + "std": 2501.0428875679136, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_2": { + "name": "feature_1_2", + "role": "numerical", + "statistics": { + "count": 459, + "approx_unique": 17, + "avg": 882447.0588235294, + "min": 0.0, + "max": 68601600.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 6212366.872861004, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_3": { + "name": "feature_1_3", + "role": "numerical", + "statistics": { + "count": 459, + "approx_unique": 46, + "avg": 15.858387799564266, + "min": 0.0, + "max": 100.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 30.971326900401827, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_4": { + "name": "feature_1_4", + "role": "numerical", + "statistics": { + "count": 459, + "approx_unique": 20, + "avg": 1.2352941176470589, + "min": 0.0, + "max": 24.0, + "q25": 0.0, + "q50": 0.0, + "q75": 1.0, + "std": 2.817052035928917, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_5": { + "name": "feature_1_5", + "role": "numerical", + "statistics": { + "count": 459, + "approx_unique": 34, + "avg": 7.1725490196078425, + "min": 0.0, + "max": 100.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 22.558438138781643, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_6": { + "name": "feature_1_6", + "role": "numerical", + "statistics": { + "count": 459, + "approx_unique": 53, + "avg": 111.88671023965142, + "min": 0.0, + "max": 167.0, + "q25": 101.6388888888889, + "q50": 113.53061224489795, + "q75": 131.20138888888889, + "std": 39.75240260604348, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_7": { + "name": "feature_1_7", + "role": "numerical", + "statistics": { + "count": 459, + "approx_unique": 75, + "avg": 9055.906318082789, + "min": 0.0, + "max": 12541.0, + "q25": 8516.840277777777, + "q50": 8967.08163265306, + "q75": 9895.083333333334, + "std": 2308.773928846936, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_8": { + "name": "feature_1_8", + "role": "numerical", + "statistics": { + "count": 459, + "approx_unique": 19, + "avg": 2.6230936819172115, + "min": 0.0, + "max": 95.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 12.698880328094846, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_9": { + "name": "feature_1_9", + "role": "numerical", + "statistics": { + "count": 459, + "approx_unique": 7, + "avg": 0.2324400871459697, + "min": 0.0, + "max": 7.01, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.898713135182863, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_10": { + "name": "feature_1_10", + "role": "numerical", + "statistics": { + "count": 459, + "approx_unique": 23, + "avg": 0.1993464052287582, + "min": 0.0, + "max": 6.6, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.7869983380593814, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "duration": { + "name": "duration", + "role": "numerical", + "statistics": { + "count": 459, + "approx_unique": 5, + "avg": 37.12418300653595, + "min": 12.0, + "max": 60.0, + "q25": 24.0, + "q50": 36.0, + "q75": 48.0, + "std": 16.81208246952378, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "payments": { + "name": "payments", + "role": "numerical", + "statistics": { + "count": 459, + "approx_unique": 585, + "avg": 4185.23311546841, + "min": 312.0, + "max": 9910.0, + "q25": 2375.409722222222, + "q50": 3976.8571428571427, + "q75": 5883.611111111112, + "std": 2268.721641494734, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "amount": { + "name": "amount", + "role": "numerical", + "statistics": { + "count": 459, + "approx_unique": 535, + "avg": 154961.38562091504, + "min": 4980.0, + "max": 590820.0, + "q25": 67434.16666666667, + "q50": 121004.81632653062, + "q75": 216506.33333333334, + "std": 116425.1930214991, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + } + } + }, + "test": { + "name": "features.test", + "path": "pipeline/feature_sets/features.test.parquet", + "profile": { + "date_loan": { + "name": "date_loan", + "role": "time_stamp", + "statistics": { + "count": 223, + "approx_unique": 182, + "avg": "1996-11-22T01:49:46.547085", + "min": "1993-11-10T00:00:00", + "max": "1998-12-06T00:00:00", + "q25": "1995-11-23T07:20:00", + "q50": "1997-04-28T16:00:00", + "q75": "1998-01-15T20:00:00", + "std": null, + "null_percentage": 0.0, + "column_type": "TIMESTAMP_NS", + "type": "time_stamp" + } + }, + "account_id": { + "name": "account_id", + "role": "join_key", + "statistics": { + "count": 223, + "approx_unique": 203, + "min": "10005", + "max": "993", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "join_key" + } + }, + "default": { + "name": "default", + "role": "target", + "statistics": { + "count": 223, + "approx_unique": 2, + "avg": 0.09417040358744394, + "min": 0.0, + "max": 1.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.29272270742877293, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "feature_1_1": { + "name": "feature_1_1", + "role": "numerical", + "statistics": { + "count": 223, + "approx_unique": 28, + "avg": 791.0224215246636, + "min": 0.0, + "max": 18200.0, + "q25": 0.0, + "q50": 0.0, + "q75": 120.41666666666667, + "std": 2808.7462985761595, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_2": { + "name": "feature_1_2", + "role": "numerical", + "statistics": { + "count": 223, + "approx_unique": 11, + "avg": 1550550.67264574, + "min": 0.0, + "max": 128390400.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 10521062.635618178, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_3": { + "name": "feature_1_3", + "role": "numerical", + "statistics": { + "count": 223, + "approx_unique": 27, + "avg": 14.7, + "min": 0.0, + "max": 100.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 29.76500454385141, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_4": { + "name": "feature_1_4", + "role": "numerical", + "statistics": { + "count": 223, + "approx_unique": 13, + "avg": 1.201793721973094, + "min": 0.0, + "max": 14.0, + "q25": 0.0, + "q50": 0.0, + "q75": 1.0, + "std": 2.3209962936410613, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_5": { + "name": "feature_1_5", + "role": "numerical", + "statistics": { + "count": 223, + "approx_unique": 13, + "avg": 3.6977578475336323, + "min": 0.0, + "max": 100.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 15.026950095889092, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_6": { + "name": "feature_1_6", + "role": "numerical", + "statistics": { + "count": 223, + "approx_unique": 49, + "avg": 113.81165919282512, + "min": 0.0, + "max": 167.0, + "q25": 100.0, + "q50": 111.0, + "q75": 127.16666666666667, + "std": 31.72446761464842, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_7": { + "name": "feature_1_7", + "role": "numerical", + "statistics": { + "count": 223, + "approx_unique": 63, + "avg": 9169.70403587444, + "min": 0.0, + "max": 12541.0, + "q25": 8444.0, + "q50": 8905.666666666666, + "q75": 9925.222222222223, + "std": 1980.4491806294118, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_8": { + "name": "feature_1_8", + "role": "numerical", + "statistics": { + "count": 223, + "approx_unique": 9, + "avg": 2.9596412556053813, + "min": 0.0, + "max": 75.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 12.981732968356484, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_9": { + "name": "feature_1_9", + "role": "numerical", + "statistics": { + "count": 223, + "approx_unique": 7, + "avg": 0.2825112107623318, + "min": 0.0, + "max": 7.01, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 1.114162299388315, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_10": { + "name": "feature_1_10", + "role": "numerical", + "statistics": { + "count": 223, + "approx_unique": 17, + "avg": 0.20986547085201795, + "min": 0.0, + "max": 6.6, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.8666449130086721, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "duration": { + "name": "duration", + "role": "numerical", + "statistics": { + "count": 223, + "approx_unique": 5, + "avg": 35.19282511210762, + "min": 12.0, + "max": 60.0, + "q25": 24.0, + "q50": 36.0, + "q75": 48.0, + "std": 17.571310118488245, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "payments": { + "name": "payments", + "role": "numerical", + "statistics": { + "count": 223, + "approx_unique": 214, + "avg": 4201.8430493273545, + "min": 304.0, + "max": 9721.0, + "q25": 2527.722222222222, + "q50": 3888.6666666666665, + "q75": 5700.5, + "std": 2107.7211804113517, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "amount": { + "name": "amount", + "role": "numerical", + "statistics": { + "count": 223, + "approx_unique": 223, + "avg": 144100.73542600896, + "min": 10944.0, + "max": 566640.0, + "q25": 62054.0, + "q50": 108992.0, + "q75": 198987.0, + "std": 106696.63113384871, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + } + } + } + } +} \ No newline at end of file diff --git a/tests/integration/data/loans/loans.py b/tests/integration/data/loans/loans.py new file mode 100644 index 0000000..b9055e9 --- /dev/null +++ b/tests/integration/data/loans/loans.py @@ -0,0 +1,90 @@ +from __future__ import annotations + +from pathlib import Path +from typing import cast + +from getml.data import Container, DataFrame, DataModel +from getml.feature_learning import Multirel +from getml.feature_learning.loss_functions import CrossEntropyLoss +from getml.pipeline import Pipeline +from getml.predictors import ( + XGBoostClassifier, +) +from pydantic.dataclasses import dataclass +from typing_extensions import override + +from tests.integration.data.datasets import DataSetName +from tests.integration.data.getmlproject import ( + GetMLProject, + GetMLProjectBundle, + GetMLProjectFactory, + getml_project_bundle, +) + + +@dataclass +class LoansProject(GetMLProject): + pass + + +class LoansProjectFactory(GetMLProjectFactory): + @override + def create( + self, + project_name: str, + session_cache_dir: Path, + ) -> LoansProject: + dataset_name: DataSetName = DataSetName.LOANS + with getml_project_bundle( + GetMLProjectBundle( + project_name, + session_cache_dir, + dataset_name, + ), + ) as project_bundle: + name: str = project_bundle.name + container = self._load_getml_container(dataset_name) + data_model = self._get_data_model(container) + pipeline = self._ensure_fitted_pipeline( + lambda: self._create_pipeline(data_model), + container, + ) + return LoansProject( + name=name, + pipeline=pipeline, + container=container, + ) + + def _get_data_model(self, container: Container) -> DataModel: + population_subsets = cast( + "dict[str, DataFrame]", + cast("object", container.subsets), + ) + peripheral_dataframes = cast( + "dict[str, DataFrame]", + cast("object", container.peripheral), + ) + + population_ph = population_subsets["train"].to_placeholder("population") + peripheral_phs = [ + dataframe.to_placeholder() for dataframe in peripheral_dataframes.values() + ] + + data_model = DataModel(population=population_ph) + data_model.add(*peripheral_phs) + data_model.population.join( + data_model.trans, + on="account_id", + time_stamps=("date_loan", "date"), + ) + data_model.population.join(data_model.order, on="account_id") + data_model.population.join(data_model.meta, on="account_id") + return data_model + + def _create_pipeline(self, data_model: DataModel) -> Pipeline: + return Pipeline( + data_model=data_model, + feature_learners=[Multirel(num_features=10)], + predictors=[XGBoostClassifier()], + loss_function=CrossEntropyLoss, + ) diff --git a/tests/integration/data/numerical/__init__.py b/tests/integration/data/numerical/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/integration/data/numerical/expected.container.json b/tests/integration/data/numerical/expected.container.json new file mode 100644 index 0000000..970cb2a --- /dev/null +++ b/tests/integration/data/numerical/expected.container.json @@ -0,0 +1,210 @@ +{ + "id": "numerical", + "population": null, + "peripheral": { + "perph": { + "name": "perph", + "path": "container/peripheral/perph.parquet", + "profile": { + "time_stamp": { + "name": "time_stamp", + "role": "time_stamp", + "statistics": { + "count": 125000, + "approx_unique": 109737, + "avg": "1970-01-01T00:00:00.499724", + "min": "1970-01-01T00:00:00.000001", + "max": "1970-01-01T00:00:00.999992", + "q25": "1970-01-01T00:00:00.251657", + "q50": "1970-01-01T00:00:00.498147", + "q75": "1970-01-01T00:00:00.749514", + "std": null, + "null_percentage": 0.0, + "column_type": "TIMESTAMP_NS", + "type": "time_stamp" + } + }, + "join_key": { + "name": "join_key", + "role": "join_key", + "statistics": { + "count": 125000, + "approx_unique": 500, + "min": "0", + "max": "99", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "join_key" + } + }, + "column_01": { + "name": "column_01", + "role": "numerical", + "statistics": { + "count": 125000, + "approx_unique": 111605, + "avg": 0.0013288327706683126, + "min": -0.9999877476408228, + "max": 0.9999988204502579, + "q25": -0.5006578527430887, + "q50": -0.00005564061036791986, + "q75": 0.5030212144114071, + "std": 0.5786674904012853, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + } + } + } + }, + "subsets": { + "train": { + "name": "train", + "path": "container/subsets/train.parquet", + "profile": { + "time_stamp": { + "name": "time_stamp", + "role": "time_stamp", + "statistics": { + "count": 390, + "approx_unique": 460, + "avg": "1970-01-01T00:00:00.514975", + "min": "1970-01-01T00:00:00.000426", + "max": "1970-01-01T00:00:00.998435", + "q25": "1970-01-01T00:00:00.271797", + "q50": "1970-01-01T00:00:00.525929", + "q75": "1970-01-01T00:00:00.755042", + "std": null, + "null_percentage": 0.0, + "column_type": "TIMESTAMP_NS", + "type": "time_stamp" + } + }, + "join_key": { + "name": "join_key", + "role": "join_key", + "statistics": { + "count": 390, + "approx_unique": 359, + "min": "0", + "max": "99", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "join_key" + } + }, + "targets": { + "name": "targets", + "role": "target", + "statistics": { + "count": 390, + "approx_unique": 155, + "avg": 96.17692307692307, + "min": 0.0, + "max": 155.0, + "q25": 63.8, + "q50": 113.30555555555556, + "q75": 126.4, + "std": 40.834822842459396, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "column_01": { + "name": "column_01", + "role": "numerical", + "statistics": { + "count": 390, + "approx_unique": 366, + "avg": 0.007274057420148274, + "min": -0.9999830328625017, + "max": 0.9963392528271888, + "q25": -0.49190003744948635, + "q50": 0.007745629121322521, + "q75": 0.5430378770360742, + "std": 0.5852675384296699, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + } + } + }, + "test": { + "name": "test", + "path": "container/subsets/test.parquet", + "profile": { + "time_stamp": { + "name": "time_stamp", + "role": "time_stamp", + "statistics": { + "count": 110, + "approx_unique": 111, + "avg": "1970-01-01T00:00:00.512566", + "min": "1970-01-01T00:00:00.005357", + "max": "1970-01-01T00:00:00.999120", + "q25": "1970-01-01T00:00:00.265168", + "q50": "1970-01-01T00:00:00.526890", + "q75": "1970-01-01T00:00:00.760226", + "std": null, + "null_percentage": 0.0, + "column_type": "TIMESTAMP_NS", + "type": "time_stamp" + } + }, + "join_key": { + "name": "join_key", + "role": "join_key", + "statistics": { + "count": 110, + "approx_unique": 116, + "min": "10", + "max": "97", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "join_key" + } + }, + "targets": { + "name": "targets", + "role": "target", + "statistics": { + "count": 110, + "approx_unique": 66, + "avg": 93.48181818181818, + "min": 1.0, + "max": 150.0, + "q25": 62.0, + "q50": 110.5, + "q75": 125.0, + "std": 39.905331049938304, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "column_01": { + "name": "column_01", + "role": "numerical", + "statistics": { + "count": 110, + "approx_unique": 117, + "avg": 0.05299560208754448, + "min": -0.953856078472245, + "max": 0.9980389778878485, + "q25": -0.4113366684427884, + "q50": 0.06708147454405011, + "q75": 0.5614427664757271, + "std": 0.5410740412382254, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + } + } + } + }, + "deep_copy": false +} \ No newline at end of file diff --git a/tests/integration/data/numerical/expected.pipeline.json b/tests/integration/data/numerical/expected.pipeline.json new file mode 100644 index 0000000..0379765 --- /dev/null +++ b/tests/integration/data/numerical/expected.pipeline.json @@ -0,0 +1,521 @@ +{ + "id": "dzARR1", + "predictions": { + "train": { + "name": "train", + "path": "pipeline/predictions/train.parquet" + }, + "test": { + "name": "test", + "path": "pipeline/predictions/test.parquet" + } + }, + "feature_sets": { + "train": { + "name": "features.train", + "path": "pipeline/feature_sets/features.train.parquet", + "profile": { + "time_stamp": { + "name": "time_stamp", + "role": "time_stamp", + "statistics": { + "count": 390, + "approx_unique": 460, + "avg": "1970-01-01T00:00:00.514975", + "min": "1970-01-01T00:00:00.000426", + "max": "1970-01-01T00:00:00.998435", + "q25": "1970-01-01T00:00:00.271797", + "q50": "1970-01-01T00:00:00.525929", + "q75": "1970-01-01T00:00:00.755042", + "std": null, + "null_percentage": 0.0, + "column_type": "TIMESTAMP_NS", + "type": "time_stamp" + } + }, + "join_key": { + "name": "join_key", + "role": "join_key", + "statistics": { + "count": 390, + "approx_unique": 359, + "min": "0", + "max": "99", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "join_key" + } + }, + "targets": { + "name": "targets", + "role": "target", + "statistics": { + "count": 390, + "approx_unique": 155, + "avg": 96.17692307692307, + "min": 0.0, + "max": 155.0, + "q25": 63.8, + "q50": 113.30555555555556, + "q75": 126.4, + "std": 40.834822842459396, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "feature_1_1": { + "name": "feature_1_1", + "role": "numerical", + "statistics": { + "count": 390, + "approx_unique": 409, + "avg": 96.16907668121702, + "min": 0.0, + "max": 154.958538372792, + "q25": 63.7858157217645, + "q50": 113.27765320314404, + "q75": 126.50463010411374, + "std": 40.831795142709815, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_2": { + "name": "feature_1_2", + "role": "numerical", + "statistics": { + "count": 390, + "approx_unique": 375, + "avg": 0.8376766309834969, + "min": -0.005741885599707359, + "max": 2.7194084335179305, + "q25": 0.652078199793918, + "q50": 0.9700795623321786, + "q75": 1.0064016977526749, + "std": 0.25570143177465654, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_3": { + "name": "feature_1_3", + "role": "numerical", + "statistics": { + "count": 390, + "approx_unique": 385, + "avg": 86.38617317829302, + "min": 0.0, + "max": 139.48311171572644, + "q25": 57.23467415456807, + "q50": 101.87912254707506, + "q75": 113.60643119883323, + "std": 36.712671335094534, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_4": { + "name": "feature_1_4", + "role": "numerical", + "statistics": { + "count": 390, + "approx_unique": 410, + "avg": 1.486671539444774, + "min": 0.0, + "max": 18.07352556914617, + "q25": 0.5113719486389163, + "q50": 0.6982874132646059, + "q75": 1.482302195795544, + "std": 2.4958715677627152, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_5": { + "name": "feature_1_5", + "role": "numerical", + "statistics": { + "count": 390, + "approx_unique": 316, + "avg": 78.06387842451362, + "min": 0.0, + "max": 125.92644437182132, + "q25": 51.625347761997176, + "q50": 92.20745748713266, + "q75": 102.69796763001868, + "std": 33.211534248078024, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_6": { + "name": "feature_1_6", + "role": "numerical", + "statistics": { + "count": 390, + "approx_unique": 448, + "avg": 0.5609713545812214, + "min": -1.8843295948745304, + "max": 7.3863370740225225, + "q25": 0.3106364637147931, + "q50": 0.4926810309502056, + "q75": 0.589746691497219, + "std": 1.0748256879417633, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_7": { + "name": "feature_1_7", + "role": "numerical", + "statistics": { + "count": 390, + "approx_unique": 401, + "avg": 70.10412027365548, + "min": 0.0, + "max": 113.10321385166299, + "q25": 46.53178780372958, + "q50": 82.55886648685942, + "q75": 92.25996193856125, + "std": 29.748700279909087, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_8": { + "name": "feature_1_8", + "role": "numerical", + "statistics": { + "count": 390, + "approx_unique": 430, + "avg": 0.514033325846855, + "min": -0.4440243803830779, + "max": 0.949369395172385, + "q25": 0.40480853219332824, + "q50": 0.6491476769330858, + "q75": 0.6766508980468096, + "std": 0.2595060637322195, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_9": { + "name": "feature_1_9", + "role": "numerical", + "statistics": { + "count": 390, + "approx_unique": 384, + "avg": 62.90321872321439, + "min": 0.0, + "max": 101.788803667452, + "q25": 41.77890864643118, + "q50": 74.08221392647076, + "q75": 82.57089164834606, + "std": 26.689815669012102, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_10": { + "name": "feature_1_10", + "role": "numerical", + "statistics": { + "count": 390, + "approx_unique": 361, + "avg": 0.4964582603881268, + "min": -0.453809371715282, + "max": 8.22465349938976, + "q25": -0.013087906353886864, + "q50": 0.16252383065828194, + "q75": 0.32139660116655816, + "std": 1.3656064778547599, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "column_01": { + "name": "column_01", + "role": "numerical", + "statistics": { + "count": 390, + "approx_unique": 366, + "avg": 0.007274057420148274, + "min": -0.9999830328625017, + "max": 0.9963392528271888, + "q25": -0.49190003744948635, + "q50": 0.007745629121322521, + "q75": 0.5430378770360742, + "std": 0.5852675384296699, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + } + } + }, + "test": { + "name": "features.test", + "path": "pipeline/feature_sets/features.test.parquet", + "profile": { + "time_stamp": { + "name": "time_stamp", + "role": "time_stamp", + "statistics": { + "count": 110, + "approx_unique": 111, + "avg": "1970-01-01T00:00:00.512566", + "min": "1970-01-01T00:00:00.005357", + "max": "1970-01-01T00:00:00.999120", + "q25": "1970-01-01T00:00:00.265168", + "q50": "1970-01-01T00:00:00.526890", + "q75": "1970-01-01T00:00:00.760226", + "std": null, + "null_percentage": 0.0, + "column_type": "TIMESTAMP_NS", + "type": "time_stamp" + } + }, + "join_key": { + "name": "join_key", + "role": "join_key", + "statistics": { + "count": 110, + "approx_unique": 116, + "min": "10", + "max": "97", + "null_percentage": 0.0, + "column_type": "VARCHAR", + "type": "join_key" + } + }, + "targets": { + "name": "targets", + "role": "target", + "statistics": { + "count": 110, + "approx_unique": 66, + "avg": 93.48181818181818, + "min": 1.0, + "max": 150.0, + "q25": 62.0, + "q50": 110.5, + "q75": 125.0, + "std": 39.905331049938304, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "feature_1_1": { + "name": "feature_1_1", + "role": "numerical", + "statistics": { + "count": 110, + "approx_unique": 111, + "avg": 93.45267098578518, + "min": 1.0004581336993716, + "max": 150.31561443814144, + "q25": 61.9960947191257, + "q50": 110.66337045643346, + "q75": 124.18593897750968, + "std": 39.90174967625009, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_2": { + "name": "feature_1_2", + "role": "numerical", + "statistics": { + "count": 110, + "approx_unique": 108, + "avg": 0.8371683464686371, + "min": 0.2616188362295636, + "max": 1.3008994591492, + "q25": 0.6463480308446998, + "q50": 0.976979499386938, + "q75": 0.9981102813038182, + "std": 0.22694451760592796, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_3": { + "name": "feature_1_3", + "role": "numerical", + "statistics": { + "count": 110, + "approx_unique": 140, + "avg": 83.92568798146601, + "min": 0.8936319178549653, + "max": 135.34260543221865, + "q25": 55.618658113985575, + "q50": 99.41231630964873, + "q75": 112.1077854754618, + "std": 35.8615898850991, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_4": { + "name": "feature_1_4", + "role": "numerical", + "statistics": { + "count": 110, + "approx_unique": 121, + "avg": 1.3729637341834586, + "min": 0.261503923197538, + "max": 14.741123450931518, + "q25": 0.5079183380724014, + "q50": 0.7330302592870825, + "q75": 1.5598762921374063, + "std": 2.1587383317017386, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_5": { + "name": "feature_1_5", + "role": "numerical", + "statistics": { + "count": 110, + "approx_unique": 120, + "avg": 75.8412119711527, + "min": 0.8078674007375028, + "max": 122.03529180787704, + "q25": 50.168825830397346, + "q50": 90.3025019699042, + "q75": 101.01097835627549, + "std": 32.4378848933766, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_6": { + "name": "feature_1_6", + "role": "numerical", + "statistics": { + "count": 110, + "approx_unique": 101, + "avg": 0.5049229013397559, + "min": -1.0234322123164012, + "max": 6.118363465758665, + "q25": 0.1428351156399801, + "q50": 0.4803652747349002, + "q75": 0.5681416543619112, + "std": 1.0283977404632196, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_7": { + "name": "feature_1_7", + "role": "numerical", + "statistics": { + "count": 110, + "approx_unique": 105, + "avg": 68.1177127554369, + "min": 0.7276733948503948, + "max": 109.66181307295999, + "q25": 45.19785585450378, + "q50": 80.4634801504877, + "q75": 90.96212075432149, + "std": 29.061616382307164, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_8": { + "name": "feature_1_8", + "role": "numerical", + "statistics": { + "count": 110, + "approx_unique": 101, + "avg": 0.4979052918487878, + "min": -0.7685655011257438, + "max": 0.8965485722446492, + "q25": 0.31406675057102806, + "q50": 0.6465958189908928, + "q75": 0.6755108754778928, + "std": 0.27431090438821965, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_9": { + "name": "feature_1_9", + "role": "numerical", + "statistics": { + "count": 110, + "approx_unique": 125, + "avg": 61.12278600297129, + "min": 0.6534488975862575, + "max": 98.15463652421363, + "q25": 40.591311515103115, + "q50": 71.44444119850576, + "q75": 81.54953124372442, + "std": 26.07679480798724, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_10": { + "name": "feature_1_10", + "role": "numerical", + "statistics": { + "count": 110, + "approx_unique": 113, + "avg": 0.3782221036599077, + "min": -0.9960609366948441, + "max": 6.97305844251124, + "q25": -0.02509066172728069, + "q50": 0.16454383872023082, + "q75": 0.30357637470021315, + "std": 1.150968935924188, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "column_01": { + "name": "column_01", + "role": "numerical", + "statistics": { + "count": 110, + "approx_unique": 117, + "avg": 0.05299560208754448, + "min": -0.953856078472245, + "max": 0.9980389778878485, + "q25": -0.4113366684427884, + "q50": 0.06708147454405011, + "q75": 0.5614427664757271, + "std": 0.5410740412382254, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + } + } + } + } +} \ No newline at end of file diff --git a/tests/integration/data/numerical/numerical.py b/tests/integration/data/numerical/numerical.py new file mode 100644 index 0000000..de60674 --- /dev/null +++ b/tests/integration/data/numerical/numerical.py @@ -0,0 +1,80 @@ +from __future__ import annotations + +from pathlib import Path + +from getml.data import Container, DataModel +from getml.feature_learning import RelMT +from getml.feature_learning.loss_functions import SquareLoss +from getml.pipeline import Pipeline +from getml.predictors import ( + XGBoostRegressor, +) +from pydantic.dataclasses import dataclass +from typing_extensions import override + +from getml_io.utils.convert import ( + assume_is_dict_str_to_dataframe_or_view, +) +from tests.integration.data.datasets import DataSetName +from tests.integration.data.getmlproject import ( + GetMLProject, + GetMLProjectBundle, + GetMLProjectFactory, + getml_project_bundle, +) + + +@dataclass +class NumericalProject(GetMLProject): + pass + + +class NumericalProjectFactory(GetMLProjectFactory): + @override + def create( + self, + project_name: str, + session_cache_dir: Path, + ) -> NumericalProject: + dataset_name: DataSetName = DataSetName.NUMERICAL + with getml_project_bundle( + GetMLProjectBundle( + project_name, + session_cache_dir, + dataset_name, + ), + ) as project_bundle: + name: str = project_bundle.name + container = self._load_getml_container(dataset_name) + data_model = self._get_data_model(container) + pipeline = self._ensure_fitted_pipeline( + lambda: self._create_pipeline(data_model), + container, + ) + return NumericalProject( + name=name, + pipeline=pipeline, + container=container, + ) + + def _get_data_model(self, container: Container) -> DataModel: + train = assume_is_dict_str_to_dataframe_or_view(container.subsets)["train"] + population = train.to_placeholder("population") + perph = assume_is_dict_str_to_dataframe_or_view(container.peripheral)["perph"] + peripheral = perph.to_placeholder("perph") + data_model = DataModel(population=population) + data_model.add(peripheral) + data_model.population.join( + data_model.perph, + on="join_key", + time_stamps="time_stamp", + ) + return data_model + + def _create_pipeline(self, data_model: DataModel) -> Pipeline: + return Pipeline( + data_model=data_model, + feature_learners=[RelMT(num_features=10)], + predictors=[XGBoostRegressor()], + loss_function=SquareLoss, + ) diff --git a/tests/integration/data/robot/__init__.py b/tests/integration/data/robot/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/integration/data/robot/expected.container.json b/tests/integration/data/robot/expected.container.json new file mode 100644 index 0000000..3b9a1c0 --- /dev/null +++ b/tests/integration/data/robot/expected.container.json @@ -0,0 +1,7017 @@ +{ + "id": "vkeNr3", + "population": null, + "peripheral": { + "full": { + "name": "full", + "path": "container/peripheral/full.parquet", + "profile": { + "rowid": { + "name": "rowid", + "role": "time_stamp", + "statistics": { + "count": 150, + "approx_unique": 181, + "avg": 74.5, + "min": 0.0, + "max": 149.0, + "q25": 37.0, + "q50": 74.5, + "q75": 112.0, + "std": 43.445367992456916, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "time_stamp_float" + } + }, + "f_x": { + "name": "f_x", + "role": "target", + "statistics": { + "count": 150, + "approx_unique": 122, + "avg": -10.736973333333335, + "min": -11.28, + "max": -10.06, + "q25": -10.873750000000001, + "q50": -10.71125, + "q75": -10.607125, + "std": 0.22850655921934376, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "f_y": { + "name": "f_y", + "role": "target", + "statistics": { + "count": 150, + "approx_unique": 132, + "avg": 6.446155333333332, + "min": 5.93, + "max": 6.9718, + "q25": 6.3054875, + "q50": 6.470575, + "q75": 6.59755, + "std": 0.2311467814369908, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "f_z": { + "name": "f_z", + "role": "target", + "statistics": { + "count": 150, + "approx_unique": 100, + "avg": -7.623038666666668, + "min": -7.99, + "max": -7.2267, + "q25": -7.71245, + "q50": -7.637525, + "q75": -7.548449999999999, + "std": 0.1431465578291859, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "3": { + "name": "3", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 3.409800000000007, + "min": 3.4098, + "max": 3.4098, + "q25": 3.4098, + "q50": 3.4098, + "q75": 3.4098, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "4": { + "name": "4", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": -0.32737000000000016, + "min": -0.32737, + "max": -0.32737, + "q25": -0.32737, + "q50": -0.32737, + "q75": -0.32737, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "5": { + "name": "5", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.9604400000000025, + "min": 0.96044, + "max": 0.96044, + "q25": 0.96044, + "q50": 0.96044, + "q75": 0.96044, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "6": { + "name": "6", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": -3.743600000000005, + "min": -3.7436, + "max": -3.7436, + "q25": -3.7436, + "q50": -3.7436, + "q75": -3.7436, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "7": { + "name": "7", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": -1.0190999999999997, + "min": -1.0191, + "max": -1.0191, + "q25": -1.0191, + "q50": -1.0191, + "q75": -1.0191, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "8": { + "name": "8", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": -6.020499999999994, + "min": -6.0205, + "max": -6.0205, + "q25": -6.0205, + "q50": -6.0205, + "q75": -6.0205, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "9": { + "name": "9", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "10": { + "name": "10", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "11": { + "name": "11", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "12": { + "name": "12", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "13": { + "name": "13", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "14": { + "name": "14", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "15": { + "name": "15", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "16": { + "name": "16", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "17": { + "name": "17", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "18": { + "name": "18", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "19": { + "name": "19", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "20": { + "name": "20", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "21": { + "name": "21", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 8.380399999999991e-17, + "min": 8.3804e-17, + "max": 8.3804e-17, + "q25": 8.3804e-17, + "q50": 8.3804e-17, + "q75": 8.3804e-17, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "22": { + "name": "22", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": -4.811599999999999, + "min": -4.8116, + "max": -4.8116, + "q25": -4.8116, + "q50": -4.8116, + "q75": -4.8116, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "23": { + "name": "23", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": -1.4033000000000013, + "min": -1.4033, + "max": -1.4033, + "q25": -1.4033, + "q50": -1.4033, + "q75": -1.4033, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "24": { + "name": "24", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": -0.13685999999999993, + "min": -0.13685999999999998, + "max": -0.13685999999999998, + "q25": -0.13685999999999998, + "q50": -0.13685999999999998, + "q75": -0.13685999999999998, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "25": { + "name": "25", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.002471900000000008, + "min": 0.0024719, + "max": 0.0024719, + "q25": 0.0024719, + "q50": 0.0024719, + "q75": 0.0024719, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "26": { + "name": "26", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "27": { + "name": "27", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 9.80270000000001e-16, + "min": 9.8027e-16, + "max": 9.8027e-16, + "q25": 9.8027e-16, + "q50": 9.8027e-16, + "q75": 9.8027e-16, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "28": { + "name": "28", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": -55.64199999999989, + "min": -55.641999999999996, + "max": -55.641999999999996, + "q25": -55.641999999999996, + "q50": -55.641999999999996, + "q75": -55.641999999999996, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "29": { + "name": "29", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": -16.311999999999948, + "min": -16.312, + "max": -16.312, + "q25": -16.312, + "q50": -16.312, + "q75": -16.312, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "30": { + "name": "30", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": -1.204199999999996, + "min": -1.2042, + "max": -1.2042, + "q25": -1.2042, + "q50": -1.2042, + "q75": -1.2042, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "31": { + "name": "31", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.021675000000000076, + "min": 0.021675, + "max": 0.021675, + "q25": 0.021675, + "q50": 0.021675, + "q75": 0.021675, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "32": { + "name": "32", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "33": { + "name": "33", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 2, + "avg": 3.4097893333333382, + "min": 3.4097, + "max": 3.4098, + "q25": 3.4098, + "q50": 3.4098, + "q75": 3.4098, + "std": 0.00003097231209211525, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "34": { + "name": "34", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 10, + "avg": -0.32737406666666663, + "min": -0.32742, + "max": -0.32733, + "q25": -0.32739, + "q50": -0.32737, + "q75": -0.32736, + "std": 0.000019596488750918528, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "35": { + "name": "35", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 9, + "avg": 0.9604308000000004, + "min": 0.9603799999999999, + "max": 0.96047, + "q25": 0.96042, + "q50": 0.96044, + "q75": 0.9604412499999999, + "std": 0.000017359986391611932, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "36": { + "name": "36", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 2, + "avg": -3.743697333333326, + "min": -3.7437, + "max": -3.7436, + "q25": -3.7437, + "q50": -3.7437, + "q75": -3.7437, + "std": 0.000016164700403995953, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "37": { + "name": "37", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 2, + "avg": -1.0191019999999997, + "min": -1.0192, + "max": -1.0191, + "q25": -1.0191, + "q50": -1.0191, + "q75": -1.0191, + "std": 0.000014046901303907729, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "38": { + "name": "38", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": -6.020499999999994, + "min": -6.0205, + "max": -6.0205, + "q25": -6.0205, + "q50": -6.0205, + "q75": -6.0205, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "39": { + "name": "39", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "40": { + "name": "40", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "41": { + "name": "41", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": -0.0, + "max": -0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "42": { + "name": "42", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "43": { + "name": "43", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "44": { + "name": "44", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "45": { + "name": "45", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 21, + "avg": 0.11992253333333336, + "min": 0.09863999999999999, + "max": 0.14795999999999998, + "q25": 0.11433, + "q50": 0.12105999999999999, + "q75": 0.12582000000000002, + "std": 0.009229882254127401, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "46": { + "name": "46", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 16, + "avg": -6.548750000000011, + "min": -6.5685, + "max": -6.5304, + "q25": -6.5542375, + "q50": -6.5483, + "q75": -6.5438, + "std": 0.007005441317554025, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "47": { + "name": "47", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 17, + "avg": -2.815382000000002, + "min": -2.8404, + "max": -2.7888, + "q25": -2.8215749999999997, + "q50": -2.8146, + "q75": -2.8089999999999997, + "std": 0.008605344601159085, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "48": { + "name": "48", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 21, + "avg": -0.8301308000000002, + "min": -0.84335, + "max": -0.8113199999999999, + "q25": -0.8342, + "q50": -0.82962, + "q75": -0.82657, + "std": 0.005977432449184525, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "49": { + "name": "49", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 18, + "avg": 0.07019266666666672, + "min": 0.056427, + "max": 0.083877, + "q25": 0.067102, + "q50": 0.07015199999999999, + "q75": 0.07358325, + "std": 0.005338440553115666, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "50": { + "name": "50", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 25, + "avg": -0.1957868666666667, + "min": -0.21045999999999998, + "max": -0.17995, + "q25": -0.19977999999999999, + "q50": -0.19521, + "q75": -0.19120374999999998, + "std": 0.005993631646812589, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "51": { + "name": "51", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 4, + "avg": 0.11999959999999978, + "min": 0.10985, + "max": 0.12105999999999999, + "q25": 0.11882000000000001, + "q50": 0.12105999999999999, + "q75": 0.12105999999999999, + "std": 0.0015294622821381602, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "52": { + "name": "52", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": -6.548300000000016, + "min": -6.5483, + "max": -6.5483, + "q25": -6.5483, + "q50": -6.5483, + "q75": -6.5483, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "53": { + "name": "53", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": -2.815699999999996, + "min": -2.8157, + "max": -2.8157, + "q25": -2.8157, + "q50": -2.8157, + "q75": -2.8157, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "54": { + "name": "54", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 5, + "avg": -0.8297140000000008, + "min": -0.83267, + "max": -0.82657, + "q25": -0.83267, + "q50": -0.8281, + "q75": -0.8281, + "std": 0.0022419933604246145, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "55": { + "name": "55", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 2, + "avg": 0.0701723333333335, + "min": 0.07015199999999999, + "max": 0.073202, + "q25": 0.07015199999999999, + "q50": 0.07015199999999999, + "q75": 0.07015199999999999, + "std": 0.00024903145718295874, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "56": { + "name": "56", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 5, + "avg": -0.19569586666666694, + "min": -0.19826, + "max": -0.19216, + "q25": -0.19826, + "q50": -0.19521, + "q75": -0.19368, + "std": 0.002320737613206456, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "57": { + "name": "57", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 5, + "avg": 0.769904333333334, + "min": 0.76988, + "max": 0.7699199999999999, + "q25": 0.7699, + "q50": 0.7699, + "q75": 0.76991, + "std": 7.180946701202845e-6, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "58": { + "name": "58", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 7, + "avg": 0.41001886666666665, + "min": 0.40998999999999997, + "max": 0.41005, + "q25": 0.41001000000000004, + "q50": 0.41002, + "q75": 0.41003, + "std": 0.000011442102089367021, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "59": { + "name": "59", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 60, + "avg": 0.08279106666666669, + "min": 0.082732, + "max": 0.082838, + "q25": 0.082776, + "q50": 0.0827905, + "q75": 0.082803, + "std": 0.000017846724989228985, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "60": { + "name": "60", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 2, + "avg": -1.4093760000000028, + "min": -1.4094, + "max": -1.4093, + "q25": -1.4094, + "q50": -1.4094, + "q75": -1.4093875, + "std": 0.00004285138983436609, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "61": { + "name": "61", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 15, + "avg": 0.7859517333333336, + "min": 0.78588, + "max": 0.7860699999999999, + "q25": 0.78593, + "q50": 0.78595, + "q75": 0.78597, + "std": 0.00003053761387694021, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "62": { + "name": "62", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 15, + "avg": -0.3682071333333333, + "min": -0.36828, + "max": -0.36815, + "q25": -0.36823, + "q50": -0.3682075, + "q75": -0.36819, + "std": 0.00002591510835714856, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "63": { + "name": "63", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "64": { + "name": "64", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "65": { + "name": "65", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "66": { + "name": "66", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "67": { + "name": "67", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "68": { + "name": "68", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "69": { + "name": "69", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 168, + "avg": -22.282, + "min": -24.633000000000003, + "max": -20.959, + "q25": -22.644, + "q50": -22.279, + "q75": -21.84775, + "std": 0.587365486528703, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "70": { + "name": "70", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 155, + "avg": -11.360460000000002, + "min": -12.285, + "max": -10.527999999999999, + "q25": -11.524999999999999, + "q50": -11.345, + "q75": -11.213750000000001, + "std": 0.30852697509685606, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "71": { + "name": "71", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 137, + "avg": -18.56410666666667, + "min": -19.077, + "max": -18.05, + "q25": -18.68275, + "q50": -18.569, + "q75": -18.449624999999997, + "std": 0.17757384877097745, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "72": { + "name": "72", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 147, + "avg": -3.551627333333334, + "min": -3.9265, + "max": -3.241, + "q25": -3.6175874999999995, + "q50": -3.547975, + "q75": -3.4903625, + "std": 0.10976101305167409, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "73": { + "name": "73", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 140, + "avg": 5.839952666666664, + "min": 5.6508, + "max": 6.0109, + "q25": 5.790525, + "q50": 5.838900000000001, + "q75": 5.881562499999999, + "std": 0.07055825590292483, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "74": { + "name": "74", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 176, + "avg": -1.963500666666666, + "min": -2.167, + "max": -1.7896, + "q25": -2.0177250000000004, + "q50": -1.9614250000000002, + "q75": -1.913875, + "std": 0.07838604304669945, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "75": { + "name": "75", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.769900000000003, + "min": 0.7699, + "max": 0.7699, + "q25": 0.7699, + "q50": 0.7699, + "q75": 0.7699, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "76": { + "name": "76", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.41004000000000074, + "min": 0.41003999999999996, + "max": 0.41003999999999996, + "q25": 0.41003999999999996, + "q50": 0.41003999999999996, + "q75": 0.41003999999999996, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "77": { + "name": "77", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.08278199999999993, + "min": 0.08278200000000001, + "max": 0.08278200000000001, + "q25": 0.08278200000000001, + "q50": 0.08278200000000001, + "q75": 0.08278200000000001, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "78": { + "name": "78", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": -1.4094000000000033, + "min": -1.4094, + "max": -1.4094, + "q25": -1.4094, + "q50": -1.4094, + "q75": -1.4094, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "79": { + "name": "79", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.786000000000001, + "min": 0.7859999999999999, + "max": 0.7859999999999999, + "q25": 0.7859999999999999, + "q50": 0.7859999999999999, + "q75": 0.7859999999999999, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "80": { + "name": "80", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": -0.36813000000000057, + "min": -0.36813, + "max": -0.36813, + "q25": -0.36813, + "q50": -0.36813, + "q75": -0.36813, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "81": { + "name": "81", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "82": { + "name": "82", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "83": { + "name": "83", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "84": { + "name": "84", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "85": { + "name": "85", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "86": { + "name": "86", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "98": { + "name": "98", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 2, + "avg": 48.05180000000012, + "min": 48.00899999999999, + "max": 48.068999999999996, + "q25": 48.00899999999999, + "q50": 48.068999999999996, + "q75": 48.068999999999996, + "std": 0.027223164238219022, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "99": { + "name": "99", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 2, + "avg": 48.01860000000002, + "min": 48.00899999999999, + "max": 48.068999999999996, + "q25": 48.00899999999999, + "q50": 48.00899999999999, + "q75": 48.00899999999999, + "std": 0.02207005320161789, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "100": { + "name": "100", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 10, + "avg": 0.9102217999999997, + "min": 0.78776, + "max": 1.11, + "q25": 0.8593799999999999, + "q50": 0.89518, + "q75": 0.93099, + "std": 0.0513572913217397, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "101": { + "name": "101", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 7, + "avg": 47.8507333333333, + "min": 47.803000000000004, + "max": 47.895, + "q25": 47.833999999999996, + "q50": 47.849, + "q75": 47.864, + "std": 0.022350072193826037, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "102": { + "name": "102", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 5, + "avg": 47.89646666666674, + "min": 47.864, + "max": 47.925, + "q25": 47.879, + "q50": 47.895, + "q75": 47.91, + "std": 0.018259379006423344, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "103": { + "name": "103", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 5, + "avg": 47.803333333333306, + "min": 47.773, + "max": 47.833999999999996, + "q25": 47.788000000000004, + "q50": 47.803000000000004, + "q75": 47.818000000000005, + "std": 0.01844697340325772, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "104": { + "name": "104", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 4, + "avg": 47.82966666666663, + "min": 47.803000000000004, + "max": 47.849, + "q25": 47.818000000000005, + "q50": 47.833999999999996, + "q75": 47.833999999999996, + "std": 0.012021606201332025, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "105": { + "name": "105", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 4, + "avg": 47.959653333333236, + "min": 47.94, + "max": 47.986000000000004, + "q25": 47.955, + "q50": 47.955, + "q75": 47.971000000000004, + "std": 0.01211521128660683, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "106": { + "name": "106", + "role": "numerical", + "statistics": { + "count": 150, + "approx_unique": 3, + "avg": 47.962106666666585, + "min": 47.94, + "max": 47.971000000000004, + "q25": 47.955, + "q50": 47.967, + "q75": 47.971000000000004, + "std": 0.009738284420021566, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + } + } + } + }, + "subsets": { + "train": { + "name": "full", + "path": "container/subsets/train.full.parquet", + "profile": { + "rowid": { + "name": "rowid", + "role": "time_stamp", + "statistics": { + "count": 90, + "approx_unique": 117, + "avg": 44.5, + "min": 0.0, + "max": 89.0, + "q25": 22.0, + "q50": 44.5, + "q75": 67.0, + "std": 26.124700955226263, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "time_stamp_float" + } + }, + "f_x": { + "name": "f_x", + "role": "target", + "statistics": { + "count": 90, + "approx_unique": 75, + "avg": -10.733866666666666, + "min": -11.23, + "max": -10.39, + "q25": -10.852, + "q50": -10.706, + "q75": -10.632, + "std": 0.18424118291833055, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "f_y": { + "name": "f_y", + "role": "target", + "statistics": { + "count": 90, + "approx_unique": 67, + "avg": 6.4211588888888915, + "min": 5.95, + "max": 6.9718, + "q25": 6.2427, + "q50": 6.43725, + "q75": 6.59, + "std": 0.23847778305323794, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "f_z": { + "name": "f_z", + "role": "target", + "statistics": { + "count": 90, + "approx_unique": 61, + "avg": -7.6486744444444446, + "min": -7.99, + "max": -7.29, + "q25": -7.7033, + "q50": -7.641349999999999, + "q75": -7.61, + "std": 0.12120592891745888, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "3": { + "name": "3", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 3.4097999999999993, + "min": 3.4098, + "max": 3.4098, + "q25": 3.4098, + "q50": 3.4098, + "q75": 3.4098, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "4": { + "name": "4", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -0.32736999999999933, + "min": -0.32737, + "max": -0.32737, + "q25": -0.32737, + "q50": -0.32737, + "q75": -0.32737, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "5": { + "name": "5", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.9604400000000006, + "min": 0.96044, + "max": 0.96044, + "q25": 0.96044, + "q50": 0.96044, + "q75": 0.96044, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "6": { + "name": "6", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -3.7435999999999985, + "min": -3.7436, + "max": -3.7436, + "q25": -3.7436, + "q50": -3.7436, + "q75": -3.7436, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "7": { + "name": "7", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -1.0190999999999992, + "min": -1.0191, + "max": -1.0191, + "q25": -1.0191, + "q50": -1.0191, + "q75": -1.0191, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "8": { + "name": "8", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -6.020500000000011, + "min": -6.0205, + "max": -6.0205, + "q25": -6.0205, + "q50": -6.0205, + "q75": -6.0205, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "9": { + "name": "9", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "10": { + "name": "10", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "11": { + "name": "11", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "12": { + "name": "12", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "13": { + "name": "13", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "14": { + "name": "14", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "15": { + "name": "15", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "16": { + "name": "16", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "17": { + "name": "17", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "18": { + "name": "18", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "19": { + "name": "19", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "20": { + "name": "20", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "21": { + "name": "21", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 8.380400000000014e-17, + "min": 8.3804e-17, + "max": 8.3804e-17, + "q25": 8.3804e-17, + "q50": 8.3804e-17, + "q75": 8.3804e-17, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "22": { + "name": "22", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -4.811599999999999, + "min": -4.8116, + "max": -4.8116, + "q25": -4.8116, + "q50": -4.8116, + "q75": -4.8116, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "23": { + "name": "23", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -1.4033000000000013, + "min": -1.4033, + "max": -1.4033, + "q25": -1.4033, + "q50": -1.4033, + "q75": -1.4033, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "24": { + "name": "24", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -0.13686000000000026, + "min": -0.13685999999999998, + "max": -0.13685999999999998, + "q25": -0.13685999999999998, + "q50": -0.13685999999999998, + "q75": -0.13685999999999998, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "25": { + "name": "25", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0024718999999999995, + "min": 0.0024719, + "max": 0.0024719, + "q25": 0.0024719, + "q50": 0.0024719, + "q75": 0.0024719, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "26": { + "name": "26", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "27": { + "name": "27", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 9.80270000000001e-16, + "min": 9.8027e-16, + "max": 9.8027e-16, + "q25": 9.8027e-16, + "q50": 9.8027e-16, + "q75": 9.8027e-16, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "28": { + "name": "28", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -55.64199999999992, + "min": -55.641999999999996, + "max": -55.641999999999996, + "q25": -55.641999999999996, + "q50": -55.641999999999996, + "q75": -55.641999999999996, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "29": { + "name": "29", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -16.311999999999976, + "min": -16.312, + "max": -16.312, + "q25": -16.312, + "q50": -16.312, + "q75": -16.312, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "30": { + "name": "30", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -1.2042, + "min": -1.2042, + "max": -1.2042, + "q25": -1.2042, + "q50": -1.2042, + "q75": -1.2042, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "31": { + "name": "31", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.021675000000000052, + "min": 0.021675, + "max": 0.021675, + "q25": 0.021675, + "q50": 0.021675, + "q75": 0.021675, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "32": { + "name": "32", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "33": { + "name": "33", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 2, + "avg": 3.4097933333333326, + "min": 3.4097, + "max": 3.4098, + "q25": 3.4098, + "q50": 3.4098, + "q75": 3.4098, + "std": 0.000025084128112200714, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "34": { + "name": "34", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 10, + "avg": -0.3273734444444442, + "min": -0.32742, + "max": -0.32733, + "q25": -0.32739, + "q50": -0.32737, + "q75": -0.32736, + "std": 0.000019554654672256435, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "35": { + "name": "35", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 7, + "avg": 0.9604327777777777, + "min": 0.9604, + "max": 0.96047, + "q25": 0.96042, + "q50": 0.96044, + "q75": 0.96045, + "std": 0.000017224739053348342, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "36": { + "name": "36", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 2, + "avg": -3.7436955555555502, + "min": -3.7437, + "max": -3.7436, + "q25": -3.7437, + "q50": -3.7437, + "q75": -3.7437, + "std": 0.00002072349321507661, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "37": { + "name": "37", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 2, + "avg": -1.0191022222222215, + "min": -1.0192, + "max": -1.0191, + "q25": -1.0191, + "q50": -1.0191, + "q75": -1.0191, + "std": 0.000014823135407909618, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "38": { + "name": "38", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -6.020500000000011, + "min": -6.0205, + "max": -6.0205, + "q25": -6.0205, + "q50": -6.0205, + "q75": -6.0205, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "39": { + "name": "39", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "40": { + "name": "40", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "41": { + "name": "41", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": -0.0, + "max": -0.0, + "q25": -0.0, + "q50": -0.0, + "q75": -0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "42": { + "name": "42", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "43": { + "name": "43", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "44": { + "name": "44", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "45": { + "name": "45", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 21, + "avg": 0.11991266666666668, + "min": 0.09863999999999999, + "max": 0.14795999999999998, + "q25": 0.11433, + "q50": 0.12105999999999999, + "q75": 0.12554, + "std": 0.009094154166276267, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "46": { + "name": "46", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 13, + "avg": -6.548282222222224, + "min": -6.5618, + "max": -6.5304, + "q25": -6.5551, + "q50": -6.5483, + "q75": -6.5438, + "std": 0.007198089287322413, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "47": { + "name": "47", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 17, + "avg": -2.815258888888891, + "min": -2.8404, + "max": -2.7888, + "q25": -2.8224, + "q50": -2.8135, + "q75": -2.8089999999999997, + "std": 0.00938972537254334, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "48": { + "name": "48", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 20, + "avg": -0.8301134444444447, + "min": -0.84335, + "max": -0.8113199999999999, + "q25": -0.8342, + "q50": -0.82962, + "q75": -0.82657, + "std": 0.006226257764926416, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "49": { + "name": "49", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 16, + "avg": 0.07021977777777792, + "min": 0.056427, + "max": 0.083877, + "q25": 0.067102, + "q50": 0.071677, + "q75": 0.074727, + "std": 0.0056365047695782315, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "50": { + "name": "50", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 21, + "avg": -0.1953428888888889, + "min": -0.21045999999999998, + "max": -0.17995, + "q25": -0.19977999999999999, + "q50": -0.19444499999999998, + "q75": -0.19063, + "std": 0.005854349625541456, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "51": { + "name": "51", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 4, + "avg": 0.12078599999999996, + "min": 0.10985, + "max": 0.12105999999999999, + "q25": 0.12105999999999999, + "q50": 0.12105999999999999, + "q75": 0.12105999999999999, + "std": 0.0015338991953753134, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "52": { + "name": "52", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -6.548299999999999, + "min": -6.5483, + "max": -6.5483, + "q25": -6.5483, + "q50": -6.5483, + "q75": -6.5483, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "53": { + "name": "53", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -2.815699999999998, + "min": -2.8157, + "max": -2.8157, + "q25": -2.8157, + "q50": -2.8157, + "q75": -2.8157, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "54": { + "name": "54", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 5, + "avg": -0.8298086666666671, + "min": -0.83267, + "max": -0.82657, + "q25": -0.83267, + "q50": -0.8281, + "q75": -0.8281, + "std": 0.002282677414742483, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "55": { + "name": "55", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 2, + "avg": 0.07018588888888903, + "min": 0.07015199999999999, + "max": 0.073202, + "q25": 0.07015199999999999, + "q50": 0.07015199999999999, + "q75": 0.07015199999999999, + "std": 0.00032149822878378714, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "56": { + "name": "56", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 5, + "avg": -0.19520744444444438, + "min": -0.19826, + "max": -0.19216, + "q25": -0.19826, + "q50": -0.19368, + "q75": -0.19368, + "std": 0.0022294185068984654, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "57": { + "name": "57", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 4, + "avg": 0.7699038888888889, + "min": 0.76989, + "max": 0.7699199999999999, + "q25": 0.7699, + "q50": 0.7699, + "q75": 0.76991, + "std": 6.982231774226693e-6, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "58": { + "name": "58", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 6, + "avg": 0.4100198888888888, + "min": 0.40998999999999997, + "max": 0.41003999999999996, + "q25": 0.41001000000000004, + "q50": 0.41002, + "q75": 0.41003, + "std": 0.000010546253868626157, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "59": { + "name": "59", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 48, + "avg": 0.08278952222222224, + "min": 0.082732, + "max": 0.082838, + "q25": 0.082776, + "q50": 0.08279, + "q75": 0.082802, + "std": 0.000018365960072599283, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "60": { + "name": "60", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 2, + "avg": -1.409378888888891, + "min": -1.4094, + "max": -1.4093, + "q25": -1.4094, + "q50": -1.4094, + "q75": -1.4094, + "std": 0.00004103833353067418, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "61": { + "name": "61", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 13, + "avg": 0.7859538888888887, + "min": 0.78589, + "max": 0.7860699999999999, + "q25": 0.78593, + "q50": 0.78595, + "q75": 0.78598, + "std": 0.00003175377335603696, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "62": { + "name": "62", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 12, + "avg": -0.36820477777777777, + "min": -0.36828, + "max": -0.36815, + "q25": -0.36822, + "q50": -0.36821, + "q75": -0.36818, + "std": 0.000025625995306625105, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "63": { + "name": "63", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "64": { + "name": "64", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "65": { + "name": "65", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "66": { + "name": "66", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "67": { + "name": "67", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "68": { + "name": "68", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "69": { + "name": "69", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 86, + "avg": -22.28985555555556, + "min": -24.633000000000003, + "max": -20.959, + "q25": -22.635, + "q50": -22.195, + "q75": -21.851999999999997, + "std": 0.6202698680723187, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "70": { + "name": "70", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 100, + "avg": -11.364411111111112, + "min": -12.285, + "max": -10.633, + "q25": -11.526, + "q50": -11.3455, + "q75": -11.142000000000001, + "std": 0.3142770514111636, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "71": { + "name": "71", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 92, + "avg": -18.554833333333338, + "min": -18.916, + "max": -18.05, + "q25": -18.679000000000002, + "q50": -18.5795, + "q75": -18.438, + "std": 0.18080868590550767, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "72": { + "name": "72", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 84, + "avg": -3.5600688888888885, + "min": -3.9265, + "max": -3.241, + "q25": -3.6194, + "q50": -3.5422000000000002, + "q75": -3.4936, + "std": 0.11474722061645332, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "73": { + "name": "73", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 81, + "avg": 5.840498888888888, + "min": 5.6508, + "max": 6.0109, + "q25": 5.7922, + "q50": 5.8383, + "q75": 5.8821, + "std": 0.07474927303309553, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "74": { + "name": "74", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 85, + "avg": -1.9630522222222215, + "min": -2.167, + "max": -1.7896, + "q25": -2.0301, + "q50": -1.95795, + "q75": -1.9001, + "std": 0.08460407357018439, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "75": { + "name": "75", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.7699000000000005, + "min": 0.7699, + "max": 0.7699, + "q25": 0.7699, + "q50": 0.7699, + "q75": 0.7699, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "76": { + "name": "76", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.4100399999999998, + "min": 0.41003999999999996, + "max": 0.41003999999999996, + "q25": 0.41003999999999996, + "q50": 0.41003999999999996, + "q75": 0.41003999999999996, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "77": { + "name": "77", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.08278199999999993, + "min": 0.08278200000000001, + "max": 0.08278200000000001, + "q25": 0.08278200000000001, + "q50": 0.08278200000000001, + "q75": 0.08278200000000001, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "78": { + "name": "78", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -1.4094000000000022, + "min": -1.4094, + "max": -1.4094, + "q25": -1.4094, + "q50": -1.4094, + "q75": -1.4094, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "79": { + "name": "79", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.7860000000000009, + "min": 0.7859999999999999, + "max": 0.7859999999999999, + "q25": 0.7859999999999999, + "q50": 0.7859999999999999, + "q75": 0.7859999999999999, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "80": { + "name": "80", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -0.3681300000000005, + "min": -0.36813, + "max": -0.36813, + "q25": -0.36813, + "q50": -0.36813, + "q75": -0.36813, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "81": { + "name": "81", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "82": { + "name": "82", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "83": { + "name": "83", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "84": { + "name": "84", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "85": { + "name": "85", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "86": { + "name": "86", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "98": { + "name": "98", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 2, + "avg": 48.053000000000004, + "min": 48.00899999999999, + "max": 48.068999999999996, + "q25": 48.00899999999999, + "q50": 48.068999999999996, + "q75": 48.068999999999996, + "std": 0.026681643734216377, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "99": { + "name": "99", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 2, + "avg": 48.02033333333333, + "min": 48.00899999999999, + "max": 48.068999999999996, + "q25": 48.00899999999999, + "q50": 48.00899999999999, + "q75": 48.00899999999999, + "std": 0.023616790827478015, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "100": { + "name": "100", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 7, + "avg": 0.906720666666667, + "min": 0.78776, + "max": 1.11, + "q25": 0.8593799999999999, + "q50": 0.89518, + "q75": 0.93099, + "std": 0.05030257533112812, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "101": { + "name": "101", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 6, + "avg": 47.85533333333337, + "min": 47.818000000000005, + "max": 47.895, + "q25": 47.849, + "q50": 47.849, + "q75": 47.864, + "std": 0.022072403839090607, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "102": { + "name": "102", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 5, + "avg": 47.898644444444464, + "min": 47.864, + "max": 47.925, + "q25": 47.879, + "q50": 47.895, + "q75": 47.925, + "std": 0.021592919725505744, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "103": { + "name": "103", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 3, + "avg": 47.801333333333375, + "min": 47.788000000000004, + "max": 47.818000000000005, + "q25": 47.788000000000004, + "q50": 47.803000000000004, + "q75": 47.818000000000005, + "std": 0.013196867180159553, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "104": { + "name": "104", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 4, + "avg": 47.830166666666635, + "min": 47.803000000000004, + "max": 47.849, + "q25": 47.818000000000005, + "q50": 47.833999999999996, + "q75": 47.833999999999996, + "std": 0.014095381345705139, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "105": { + "name": "105", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 4, + "avg": 47.95866666666665, + "min": 47.94, + "max": 47.986000000000004, + "q25": 47.955, + "q50": 47.955, + "q75": 47.971000000000004, + "std": 0.014229262458485287, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "106": { + "name": "106", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 3, + "avg": 47.96328888888889, + "min": 47.94, + "max": 47.971000000000004, + "q25": 47.955, + "q50": 47.971000000000004, + "q75": 47.971000000000004, + "std": 0.010811193163940106, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + } + } + }, + "validation": { + "name": "full", + "path": "container/subsets/validation.full.parquet", + "profile": { + "rowid": { + "name": "rowid", + "role": "time_stamp", + "statistics": { + "count": 30, + "approx_unique": 36, + "avg": 134.5, + "min": 120.0, + "max": 149.0, + "q25": 127.0, + "q50": 134.5, + "q75": 142.0, + "std": 8.803408430829505, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "time_stamp_float" + } + }, + "f_x": { + "name": "f_x", + "role": "target", + "statistics": { + "count": 30, + "approx_unique": 32, + "avg": -10.5642, + "min": -10.932, + "max": -10.06, + "q25": -10.71, + "q50": -10.575500000000002, + "q75": -10.447000000000001, + "std": 0.23268054169345292, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "f_y": { + "name": "f_y", + "role": "target", + "statistics": { + "count": 30, + "approx_unique": 26, + "avg": 6.4535, + "min": 5.93, + "max": 6.7792, + "q25": 6.35, + "q50": 6.4831, + "q75": 6.56, + "std": 0.21875581253361343, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "f_z": { + "name": "f_z", + "role": "target", + "statistics": { + "count": 30, + "approx_unique": 27, + "avg": -7.461039999999999, + "min": -7.66, + "max": -7.2267, + "q25": -7.54, + "q50": -7.48, + "q75": -7.3936, + "std": 0.11093529832200898, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "3": { + "name": "3", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 3.409800000000001, + "min": 3.4098, + "max": 3.4098, + "q25": 3.4098, + "q50": 3.4098, + "q75": 3.4098, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "4": { + "name": "4", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -0.3273700000000001, + "min": -0.32737, + "max": -0.32737, + "q25": -0.32737, + "q50": -0.32737, + "q75": -0.32737, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "5": { + "name": "5", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.9604399999999994, + "min": 0.96044, + "max": 0.96044, + "q25": 0.96044, + "q50": 0.96044, + "q75": 0.96044, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "6": { + "name": "6", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -3.7436000000000003, + "min": -3.7436, + "max": -3.7436, + "q25": -3.7436, + "q50": -3.7436, + "q75": -3.7436, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "7": { + "name": "7", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -1.0191000000000008, + "min": -1.0191, + "max": -1.0191, + "q25": -1.0191, + "q50": -1.0191, + "q75": -1.0191, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "8": { + "name": "8", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -6.020499999999999, + "min": -6.0205, + "max": -6.0205, + "q25": -6.0205, + "q50": -6.0205, + "q75": -6.0205, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "9": { + "name": "9", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "10": { + "name": "10", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "11": { + "name": "11", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "12": { + "name": "12", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "13": { + "name": "13", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "14": { + "name": "14", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "15": { + "name": "15", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "16": { + "name": "16", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "17": { + "name": "17", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "18": { + "name": "18", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "19": { + "name": "19", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "20": { + "name": "20", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "21": { + "name": "21", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 8.380399999999998e-17, + "min": 8.3804e-17, + "max": 8.3804e-17, + "q25": 8.3804e-17, + "q50": 8.3804e-17, + "q75": 8.3804e-17, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "22": { + "name": "22", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -4.811599999999999, + "min": -4.8116, + "max": -4.8116, + "q25": -4.8116, + "q50": -4.8116, + "q75": -4.8116, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "23": { + "name": "23", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -1.4033000000000009, + "min": -1.4033, + "max": -1.4033, + "q25": -1.4033, + "q50": -1.4033, + "q75": -1.4033, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "24": { + "name": "24", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -0.13685999999999998, + "min": -0.13685999999999998, + "max": -0.13685999999999998, + "q25": -0.13685999999999998, + "q50": -0.13685999999999998, + "q75": -0.13685999999999998, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "25": { + "name": "25", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0024718999999999995, + "min": 0.0024719, + "max": 0.0024719, + "q25": 0.0024719, + "q50": 0.0024719, + "q75": 0.0024719, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "26": { + "name": "26", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "27": { + "name": "27", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 9.802700000000004e-16, + "min": 9.8027e-16, + "max": 9.8027e-16, + "q25": 9.8027e-16, + "q50": 9.8027e-16, + "q75": 9.8027e-16, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "28": { + "name": "28", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -55.64200000000003, + "min": -55.641999999999996, + "max": -55.641999999999996, + "q25": -55.641999999999996, + "q50": -55.641999999999996, + "q75": -55.641999999999996, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "29": { + "name": "29", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -16.31200000000001, + "min": -16.312, + "max": -16.312, + "q25": -16.312, + "q50": -16.312, + "q75": -16.312, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "30": { + "name": "30", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -1.2042, + "min": -1.2042, + "max": -1.2042, + "q25": -1.2042, + "q50": -1.2042, + "q75": -1.2042, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "31": { + "name": "31", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.021675, + "min": 0.021675, + "max": 0.021675, + "q25": 0.021675, + "q50": 0.021675, + "q75": 0.021675, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "32": { + "name": "32", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "33": { + "name": "33", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 3.4097866666666676, + "min": 3.4097, + "max": 3.4098, + "q25": 3.4098, + "q50": 3.4098, + "q75": 3.4098, + "std": 0.000034574590364305684, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "34": { + "name": "34", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 7, + "avg": -0.3273783333333332, + "min": -0.32741, + "max": -0.32734, + "q25": -0.3274, + "q50": -0.32737, + "q75": -0.32736, + "std": 0.000020356026530054445, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "35": { + "name": "35", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 5, + "avg": 0.9604276666666665, + "min": 0.9604, + "max": 0.96045, + "q25": 0.96042, + "q50": 0.96042, + "q75": 0.96044, + "std": 0.000015465943304497223, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "36": { + "name": "36", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -3.743700000000001, + "min": -3.7437, + "max": -3.7437, + "q25": -3.7437, + "q50": -3.7437, + "q75": -3.7437, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "37": { + "name": "37", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": -1.019103333333334, + "min": -1.0192, + "max": -1.0191, + "q25": -1.0191, + "q50": -1.0191, + "q75": -1.0191, + "std": 0.0000182574185835436, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "38": { + "name": "38", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -6.020499999999999, + "min": -6.0205, + "max": -6.0205, + "q25": -6.0205, + "q50": -6.0205, + "q75": -6.0205, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "39": { + "name": "39", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "40": { + "name": "40", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "41": { + "name": "41", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": -0.0, + "max": -0.0, + "q25": -0.0, + "q50": -0.0, + "q75": -0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "42": { + "name": "42", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "43": { + "name": "43", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "44": { + "name": "44", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "45": { + "name": "45", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 16, + "avg": 0.123375, + "min": 0.09863999999999999, + "max": 0.13899, + "q25": 0.11882000000000001, + "q50": 0.12442, + "q75": 0.13003, + "std": 0.009410180015867632, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "46": { + "name": "46", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 11, + "avg": -6.548706666666667, + "min": -6.5685, + "max": -6.5371, + "q25": -6.5551, + "q50": -6.5483, + "q75": -6.5416, + "std": 0.007517975393880323, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "47": { + "name": "47", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 11, + "avg": -2.8156400000000006, + "min": -2.8292, + "max": -2.8023, + "q25": -2.8202, + "q50": -2.8157, + "q75": -2.8089999999999997, + "std": 0.0075047846806852985, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "48": { + "name": "48", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 16, + "avg": -0.8293686666666668, + "min": -0.8418200000000001, + "max": -0.81742, + "q25": -0.83267, + "q50": -0.8281, + "q75": -0.82505, + "std": 0.005721133679150738, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "49": { + "name": "49", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 13, + "avg": 0.06994866666666667, + "min": 0.059476999999999995, + "max": 0.079302, + "q25": 0.065577, + "q50": 0.068627, + "q75": 0.073202, + "std": 0.005077370065458026, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "50": { + "name": "50", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 15, + "avg": -0.19703766666666664, + "min": -0.20893, + "max": -0.18758, + "q25": -0.20131, + "q50": -0.19673, + "q75": -0.19216, + "std": 0.005423127792839781, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "51": { + "name": "51", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.11881999999999995, + "min": 0.11882000000000001, + "max": 0.11882000000000001, + "q25": 0.11882000000000001, + "q50": 0.11882000000000001, + "q75": 0.11882000000000001, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "52": { + "name": "52", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -6.548300000000003, + "min": -6.5483, + "max": -6.5483, + "q25": -6.5483, + "q50": -6.5483, + "q75": -6.5483, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "53": { + "name": "53", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -2.8157000000000014, + "min": -2.8157, + "max": -2.8157, + "q25": -2.8157, + "q50": -2.8157, + "q75": -2.8157, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "54": { + "name": "54", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 5, + "avg": -0.8296739999999997, + "min": -0.83267, + "max": -0.82657, + "q25": -0.83267, + "q50": -0.8281, + "q75": -0.8281, + "std": 0.0020978159414348323, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "55": { + "name": "55", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.070152, + "min": 0.07015199999999999, + "max": 0.07015199999999999, + "q25": 0.07015199999999999, + "q50": 0.07015199999999999, + "q75": 0.07015199999999999, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "56": { + "name": "56", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 5, + "avg": -0.19673366666666656, + "min": -0.19826, + "max": -0.19216, + "q25": -0.19826, + "q50": -0.19826, + "q75": -0.19521, + "std": 0.0020824959880465267, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "57": { + "name": "57", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 5, + "avg": 0.7699036666666664, + "min": 0.76988, + "max": 0.7699199999999999, + "q25": 0.7699, + "q50": 0.7699, + "q75": 0.76991, + "std": 8.899179866617674e-6, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "58": { + "name": "58", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 7, + "avg": 0.4100196666666667, + "min": 0.40998999999999997, + "max": 0.41005, + "q25": 0.41001000000000004, + "q50": 0.41002, + "q75": 0.41003, + "std": 0.000013514572807192662, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "59": { + "name": "59", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 28, + "avg": 0.08279593333333332, + "min": 0.08276900000000001, + "max": 0.082833, + "q25": 0.08278200000000001, + "q50": 0.082794, + "q75": 0.08281000000000001, + "std": 0.00001697042728686539, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "60": { + "name": "60", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": -1.4093799999999999, + "min": -1.4094, + "max": -1.4093, + "q25": -1.4094, + "q50": -1.4094, + "q75": -1.4094, + "std": 0.00004068381021720471, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "61": { + "name": "61", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 10, + "avg": 0.7859436666666667, + "min": 0.78588, + "max": 0.78601, + "q25": 0.78592, + "q50": 0.78594, + "q75": 0.78596, + "std": 0.000030112814700618006, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "62": { + "name": "62", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 11, + "avg": -0.3682093333333333, + "min": -0.36826, + "max": -0.36815, + "q25": -0.36823, + "q50": -0.3682, + "q75": -0.36819, + "std": 0.000029117281671781178, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "63": { + "name": "63", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "64": { + "name": "64", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "65": { + "name": "65", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "66": { + "name": "66", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "67": { + "name": "67", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "68": { + "name": "68", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "69": { + "name": "69", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 28, + "avg": -22.26903333333333, + "min": -23.305, + "max": -21.339000000000002, + "q25": -22.645, + "q50": -22.258499999999998, + "q75": -21.991, + "std": 0.5447219780156962, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "70": { + "name": "70", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 30, + "avg": -11.434133333333332, + "min": -12.095, + "max": -10.603, + "q25": -11.642999999999999, + "q50": -11.4335, + "q75": -11.258, + "std": 0.32464003761549265, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "71": { + "name": "71", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 24, + "avg": -18.563200000000002, + "min": -19.077, + "max": -18.233, + "q25": -18.702, + "q50": -18.512999999999998, + "q75": -18.447, + "std": 0.1988744882305561, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "72": { + "name": "72", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 29, + "avg": -3.5288433333333336, + "min": -3.7051, + "max": -3.2735, + "q25": -3.5982, + "q50": -3.56235, + "q75": -3.4771, + "std": 0.10279882155279635, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "73": { + "name": "73", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 31, + "avg": 5.842810000000001, + "min": 5.7124, + "max": 5.9927, + "q25": 5.7869, + "q50": 5.84455, + "q75": 5.8891, + "std": 0.06915108072559123, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "74": { + "name": "74", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 32, + "avg": -1.9544200000000003, + "min": -2.1053, + "max": -1.8188, + "q25": -2.0024, + "q50": -1.9617, + "q75": -1.9151, + "std": 0.06628655868325775, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "75": { + "name": "75", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.7698999999999999, + "min": 0.7699, + "max": 0.7699, + "q25": 0.7699, + "q50": 0.7699, + "q75": 0.7699, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "76": { + "name": "76", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.41004000000000024, + "min": 0.41003999999999996, + "max": 0.41003999999999996, + "q25": 0.41003999999999996, + "q50": 0.41003999999999996, + "q75": 0.41003999999999996, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "77": { + "name": "77", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.08278199999999995, + "min": 0.08278200000000001, + "max": 0.08278200000000001, + "q25": 0.08278200000000001, + "q50": 0.08278200000000001, + "q75": 0.08278200000000001, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "78": { + "name": "78", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -1.4094000000000002, + "min": -1.4094, + "max": -1.4094, + "q25": -1.4094, + "q50": -1.4094, + "q75": -1.4094, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "79": { + "name": "79", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.7860000000000001, + "min": 0.7859999999999999, + "max": 0.7859999999999999, + "q25": 0.7859999999999999, + "q50": 0.7859999999999999, + "q75": 0.7859999999999999, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "80": { + "name": "80", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -0.3681300000000001, + "min": -0.36813, + "max": -0.36813, + "q25": -0.36813, + "q50": -0.36813, + "q75": -0.36813, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "81": { + "name": "81", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "82": { + "name": "82", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "83": { + "name": "83", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "84": { + "name": "84", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "85": { + "name": "85", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "86": { + "name": "86", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "98": { + "name": "98", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 48.054999999999986, + "min": 48.00899999999999, + "max": 48.068999999999996, + "q25": 48.068999999999996, + "q50": 48.068999999999996, + "q75": 48.068999999999996, + "std": 0.025810984029125853, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "99": { + "name": "99", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 48.01300000000001, + "min": 48.00899999999999, + "max": 48.068999999999996, + "q25": 48.00899999999999, + "q50": 48.00899999999999, + "q75": 48.00899999999999, + "std": 0.015222487902148182, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "100": { + "name": "100", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 6, + "avg": 0.9095060000000003, + "min": 0.8593799999999999, + "max": 1.0384, + "q25": 0.8593799999999999, + "q50": 0.89518, + "q75": 0.93099, + "std": 0.05115782709521046, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "101": { + "name": "101", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 47.85499999999999, + "min": 47.849, + "max": 47.864, + "q25": 47.849, + "q50": 47.849, + "q75": 47.864, + "std": 0.007474093186834875, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "102": { + "name": "102", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 3, + "avg": 47.891733333333335, + "min": 47.879, + "max": 47.91, + "q25": 47.879, + "q50": 47.895, + "q75": 47.895, + "std": 0.008665959299163157, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "103": { + "name": "103", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 3, + "avg": 47.793, + "min": 47.773, + "max": 47.818000000000005, + "q25": 47.773, + "q50": 47.788000000000004, + "q75": 47.818000000000005, + "std": 0.019028109877683497, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "104": { + "name": "104", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 47.82866666666668, + "min": 47.818000000000005, + "max": 47.833999999999996, + "q25": 47.818000000000005, + "q50": 47.833999999999996, + "q75": 47.833999999999996, + "std": 0.007671412823760338, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "105": { + "name": "105", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 47.96193333333334, + "min": 47.955, + "max": 47.971000000000004, + "q25": 47.955, + "q50": 47.955, + "q75": 47.971000000000004, + "std": 0.008064110927902024, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "106": { + "name": "106", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 47.960333333333324, + "min": 47.955, + "max": 47.971000000000004, + "q25": 47.955, + "q50": 47.955, + "q75": 47.971000000000004, + "std": 0.007671412823770011, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + } + } + }, + "test": { + "name": "full", + "path": "container/subsets/test.full.parquet", + "profile": { + "rowid": { + "name": "rowid", + "role": "time_stamp", + "statistics": { + "count": 30, + "approx_unique": 32, + "avg": 104.5, + "min": 90.0, + "max": 119.0, + "q25": 97.0, + "q50": 104.5, + "q75": 112.0, + "std": 8.803408430829505, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "time_stamp_float" + } + }, + "f_x": { + "name": "f_x", + "role": "target", + "statistics": { + "count": 30, + "approx_unique": 26, + "avg": -10.919066666666668, + "min": -11.28, + "max": -10.503, + "q25": -11.092, + "q50": -10.930499999999999, + "q75": -10.720999999999998, + "std": 0.21154520725519532, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "f_y": { + "name": "f_y", + "role": "target", + "statistics": { + "count": 30, + "approx_unique": 26, + "avg": 6.5138, + "min": 5.93, + "max": 6.83, + "q25": 6.4475, + "q50": 6.57335, + "q75": 6.63, + "std": 0.21305850095123235, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "f_z": { + "name": "f_z", + "role": "target", + "statistics": { + "count": 30, + "approx_unique": 30, + "avg": -7.708129999999998, + "min": -7.89, + "max": -7.48, + "q25": -7.77, + "q50": -7.7212, + "q75": -7.6182, + "std": 0.10587867210584265, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "3": { + "name": "3", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 3.409800000000001, + "min": 3.4098, + "max": 3.4098, + "q25": 3.4098, + "q50": 3.4098, + "q75": 3.4098, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "4": { + "name": "4", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -0.3273700000000001, + "min": -0.32737, + "max": -0.32737, + "q25": -0.32737, + "q50": -0.32737, + "q75": -0.32737, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "5": { + "name": "5", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.9604399999999994, + "min": 0.96044, + "max": 0.96044, + "q25": 0.96044, + "q50": 0.96044, + "q75": 0.96044, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "6": { + "name": "6", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -3.7436000000000003, + "min": -3.7436, + "max": -3.7436, + "q25": -3.7436, + "q50": -3.7436, + "q75": -3.7436, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "7": { + "name": "7", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -1.0191000000000008, + "min": -1.0191, + "max": -1.0191, + "q25": -1.0191, + "q50": -1.0191, + "q75": -1.0191, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "8": { + "name": "8", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -6.020499999999999, + "min": -6.0205, + "max": -6.0205, + "q25": -6.0205, + "q50": -6.0205, + "q75": -6.0205, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "9": { + "name": "9", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "10": { + "name": "10", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "11": { + "name": "11", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "12": { + "name": "12", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "13": { + "name": "13", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "14": { + "name": "14", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "15": { + "name": "15", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "16": { + "name": "16", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "17": { + "name": "17", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "18": { + "name": "18", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "19": { + "name": "19", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "20": { + "name": "20", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "21": { + "name": "21", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 8.380399999999998e-17, + "min": 8.3804e-17, + "max": 8.3804e-17, + "q25": 8.3804e-17, + "q50": 8.3804e-17, + "q75": 8.3804e-17, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "22": { + "name": "22", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -4.811599999999999, + "min": -4.8116, + "max": -4.8116, + "q25": -4.8116, + "q50": -4.8116, + "q75": -4.8116, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "23": { + "name": "23", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -1.4033000000000009, + "min": -1.4033, + "max": -1.4033, + "q25": -1.4033, + "q50": -1.4033, + "q75": -1.4033, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "24": { + "name": "24", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -0.13685999999999998, + "min": -0.13685999999999998, + "max": -0.13685999999999998, + "q25": -0.13685999999999998, + "q50": -0.13685999999999998, + "q75": -0.13685999999999998, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "25": { + "name": "25", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0024718999999999995, + "min": 0.0024719, + "max": 0.0024719, + "q25": 0.0024719, + "q50": 0.0024719, + "q75": 0.0024719, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "26": { + "name": "26", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "27": { + "name": "27", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 9.802700000000004e-16, + "min": 9.8027e-16, + "max": 9.8027e-16, + "q25": 9.8027e-16, + "q50": 9.8027e-16, + "q75": 9.8027e-16, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "28": { + "name": "28", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -55.64200000000003, + "min": -55.641999999999996, + "max": -55.641999999999996, + "q25": -55.641999999999996, + "q50": -55.641999999999996, + "q75": -55.641999999999996, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "29": { + "name": "29", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -16.31200000000001, + "min": -16.312, + "max": -16.312, + "q25": -16.312, + "q50": -16.312, + "q75": -16.312, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "30": { + "name": "30", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -1.2042, + "min": -1.2042, + "max": -1.2042, + "q25": -1.2042, + "q50": -1.2042, + "q75": -1.2042, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "31": { + "name": "31", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.021675, + "min": 0.021675, + "max": 0.021675, + "q25": 0.021675, + "q50": 0.021675, + "q75": 0.021675, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "32": { + "name": "32", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "33": { + "name": "33", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 3.409780000000001, + "min": 3.4097, + "max": 3.4098, + "q25": 3.4098, + "q50": 3.4098, + "q75": 3.4098, + "std": 0.00004068381021726342, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "34": { + "name": "34", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 6, + "avg": -0.3273716666666667, + "min": -0.3274, + "max": -0.32734, + "q25": -0.32739, + "q50": -0.32737, + "q75": -0.32736, + "std": 0.00001895245108948268, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "35": { + "name": "35", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 6, + "avg": 0.960428, + "min": 0.9603799999999999, + "max": 0.96045, + "q25": 0.96042, + "q50": 0.96043, + "q75": 0.96044, + "std": 0.000019190514898497155, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "36": { + "name": "36", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -3.743700000000001, + "min": -3.7437, + "max": -3.7437, + "q25": -3.7437, + "q50": -3.7437, + "q75": -3.7437, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "37": { + "name": "37", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -1.0191000000000008, + "min": -1.0191, + "max": -1.0191, + "q25": -1.0191, + "q50": -1.0191, + "q75": -1.0191, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "38": { + "name": "38", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -6.020499999999999, + "min": -6.0205, + "max": -6.0205, + "q25": -6.0205, + "q50": -6.0205, + "q75": -6.0205, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "39": { + "name": "39", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "40": { + "name": "40", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "41": { + "name": "41", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": -0.0, + "max": -0.0, + "q25": -0.0, + "q50": -0.0, + "q75": -0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "42": { + "name": "42", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "43": { + "name": "43", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "44": { + "name": "44", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "45": { + "name": "45", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 14, + "avg": 0.11649966666666664, + "min": 0.10088, + "max": 0.13227, + "q25": 0.11209000000000001, + "q50": 0.11657000000000001, + "q75": 0.12105999999999999, + "std": 0.00841944812809065, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "46": { + "name": "46", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 10, + "avg": -6.5501966666666664, + "min": -6.5663, + "max": -6.5416, + "q25": -6.5528, + "q50": -6.5506, + "q75": -6.5461, + "std": 0.0058114917862462125, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "47": { + "name": "47", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 12, + "avg": -2.815493333333334, + "min": -2.8336, + "max": -2.8023, + "q25": -2.818, + "q50": -2.8157, + "q75": -2.8089999999999997, + "std": 0.007310405117947096, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "48": { + "name": "48", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 12, + "avg": -0.8309449999999998, + "min": -0.84335, + "max": -0.8220000000000001, + "q25": -0.83572, + "q50": -0.83115, + "q75": -0.82657, + "std": 0.005530404206715397, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "49": { + "name": "49", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 13, + "avg": 0.07035533333333334, + "min": 0.062527, + "max": 0.082352, + "q25": 0.067102, + "q50": 0.07015199999999999, + "q75": 0.073202, + "std": 0.004801363551536481, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "50": { + "name": "50", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 20, + "avg": -0.19586799999999996, + "min": -0.20893, + "max": -0.18148, + "q25": -0.19977999999999999, + "q50": -0.19826, + "q75": -0.18911, + "std": 0.006909548315992475, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "51": { + "name": "51", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.11881999999999995, + "min": 0.11882000000000001, + "max": 0.11882000000000001, + "q25": 0.11882000000000001, + "q50": 0.11882000000000001, + "q75": 0.11882000000000001, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "52": { + "name": "52", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -6.548300000000003, + "min": -6.5483, + "max": -6.5483, + "q25": -6.5483, + "q50": -6.5483, + "q75": -6.5483, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "53": { + "name": "53", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -2.8157000000000014, + "min": -2.8157, + "max": -2.8157, + "q25": -2.8157, + "q50": -2.8157, + "q75": -2.8157, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "54": { + "name": "54", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 5, + "avg": -0.8294699999999999, + "min": -0.83267, + "max": -0.82657, + "q25": -0.83267, + "q50": -0.8281, + "q75": -0.8281, + "std": 0.0023114706469527574, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "55": { + "name": "55", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.070152, + "min": 0.07015199999999999, + "max": 0.07015199999999999, + "q25": 0.07015199999999999, + "q50": 0.07015199999999999, + "q75": 0.07015199999999999, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "56": { + "name": "56", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 5, + "avg": -0.1961233333333334, + "min": -0.19826, + "max": -0.19216, + "q25": -0.19826, + "q50": -0.19826, + "q75": -0.19368, + "std": 0.002457224862113459, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "57": { + "name": "57", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 3, + "avg": 0.7699063333333331, + "min": 0.7699, + "max": 0.7699199999999999, + "q25": 0.7699, + "q50": 0.76991, + "q75": 0.76991, + "std": 5.560534167661252e-6, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "58": { + "name": "58", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 5, + "avg": 0.41001499999999996, + "min": 0.41, + "max": 0.41003999999999996, + "q25": 0.41001000000000004, + "q50": 0.410015, + "q75": 0.41002, + "std": 0.000011371470653687081, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "59": { + "name": "59", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 28, + "avg": 0.08279083333333333, + "min": 0.082758, + "max": 0.082817, + "q25": 0.082774, + "q50": 0.08279249999999999, + "q75": 0.082804, + "std": 0.000016772480196858457, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "60": { + "name": "60", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": -1.4093633333333337, + "min": -1.4094, + "max": -1.4093, + "q25": -1.4094, + "q50": -1.4094, + "q75": -1.4093, + "std": 0.000049013251785353614, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "61": { + "name": "61", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 10, + "avg": 0.7859533333333333, + "min": 0.7859, + "max": 0.7859999999999999, + "q25": 0.78595, + "q50": 0.78596, + "q75": 0.78597, + "std": 0.000026565901573916655, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "62": { + "name": "62", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 9, + "avg": -0.36821200000000004, + "min": -0.36827, + "max": -0.36818, + "q25": -0.36823, + "q50": -0.36821, + "q75": -0.36819, + "std": 0.000023252734359046097, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "63": { + "name": "63", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "64": { + "name": "64", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "65": { + "name": "65", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "66": { + "name": "66", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "67": { + "name": "67", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "68": { + "name": "68", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "69": { + "name": "69", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 29, + "avg": -22.271400000000003, + "min": -23.2, + "max": -21.288, + "q25": -22.673000000000002, + "q50": -22.372, + "q75": -21.839000000000002, + "std": 0.5428036159765707, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "70": { + "name": "70", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 35, + "avg": -11.274933333333333, + "min": -11.845999999999998, + "max": -10.527999999999999, + "q25": -11.447000000000001, + "q50": -11.270499999999998, + "q75": -11.225999999999999, + "std": 0.2594811711105828, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "71": { + "name": "71", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 32, + "avg": -18.592833333333335, + "min": -18.939, + "max": -18.345, + "q25": -18.680999999999997, + "q50": -18.604, + "q75": -18.46, + "std": 0.14494566956772725, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "72": { + "name": "72", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 30, + "avg": -3.5490866666666667, + "min": -3.6931, + "max": -3.3167, + "q25": -3.6199, + "q50": -3.56555, + "q75": -3.4866, + "std": 0.10078614003417581, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "73": { + "name": "73", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 32, + "avg": 5.835456666666667, + "min": 5.7443, + "max": 5.9639, + "q25": 5.7874, + "q50": 5.8376, + "q75": 5.8786, + "std": 0.06015949309290594, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "74": { + "name": "74", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 27, + "avg": -1.9739266666666664, + "min": -2.1362, + "max": -1.845, + "q25": -2.019, + "q50": -1.97865, + "q75": -1.9192, + "std": 0.07078052008136494, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "75": { + "name": "75", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.7698999999999999, + "min": 0.7699, + "max": 0.7699, + "q25": 0.7699, + "q50": 0.7699, + "q75": 0.7699, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "76": { + "name": "76", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.41004000000000024, + "min": 0.41003999999999996, + "max": 0.41003999999999996, + "q25": 0.41003999999999996, + "q50": 0.41003999999999996, + "q75": 0.41003999999999996, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "77": { + "name": "77", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.08278199999999995, + "min": 0.08278200000000001, + "max": 0.08278200000000001, + "q25": 0.08278200000000001, + "q50": 0.08278200000000001, + "q75": 0.08278200000000001, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "78": { + "name": "78", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -1.4094000000000002, + "min": -1.4094, + "max": -1.4094, + "q25": -1.4094, + "q50": -1.4094, + "q75": -1.4094, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "79": { + "name": "79", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.7860000000000001, + "min": 0.7859999999999999, + "max": 0.7859999999999999, + "q25": 0.7859999999999999, + "q50": 0.7859999999999999, + "q75": 0.7859999999999999, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "80": { + "name": "80", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -0.3681300000000001, + "min": -0.36813, + "max": -0.36813, + "q25": -0.36813, + "q50": -0.36813, + "q75": -0.36813, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "81": { + "name": "81", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "82": { + "name": "82", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "83": { + "name": "83", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "84": { + "name": "84", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "85": { + "name": "85", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "86": { + "name": "86", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "98": { + "name": "98", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 48.04499999999999, + "min": 48.00899999999999, + "max": 48.068999999999996, + "q25": 48.00899999999999, + "q50": 48.068999999999996, + "q75": 48.068999999999996, + "std": 0.02989637274734736, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "99": { + "name": "99", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 48.019, + "min": 48.00899999999999, + "max": 48.068999999999996, + "q25": 48.00899999999999, + "q50": 48.00899999999999, + "q75": 48.00899999999999, + "std": 0.022742941307369282, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "100": { + "name": "100", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 7, + "avg": 0.9214410000000002, + "min": 0.82357, + "max": 1.0742, + "q25": 0.89518, + "q50": 0.93099, + "q75": 0.93099, + "std": 0.054774079028754794, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "101": { + "name": "101", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 4, + "avg": 47.832666666666675, + "min": 47.803000000000004, + "max": 47.864, + "q25": 47.803000000000004, + "q50": 47.833999999999996, + "q75": 47.864, + "std": 0.024358434541922255, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "102": { + "name": "102", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 3, + "avg": 47.89466666666665, + "min": 47.879, + "max": 47.91, + "q25": 47.879, + "q50": 47.895, + "q75": 47.91, + "std": 0.012874281589150457, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "103": { + "name": "103", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 3, + "avg": 47.81966666666665, + "min": 47.788000000000004, + "max": 47.833999999999996, + "q25": 47.788000000000004, + "q50": 47.833999999999996, + "q75": 47.833999999999996, + "std": 0.021283526628521798, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "104": { + "name": "104", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 3, + "avg": 47.829166666666666, + "min": 47.818000000000005, + "max": 47.849, + "q25": 47.818000000000005, + "q50": 47.833999999999996, + "q75": 47.833999999999996, + "std": 0.008477488784531828, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "105": { + "name": "105", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 47.96033333333333, + "min": 47.955, + "max": 47.971000000000004, + "q25": 47.955, + "q50": 47.955, + "q75": 47.971000000000004, + "std": 0.0076714128237685185, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "106": { + "name": "106", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 47.96033333333333, + "min": 47.955, + "max": 47.971000000000004, + "q25": 47.955, + "q50": 47.955, + "q75": 47.971000000000004, + "std": 0.007671412823767137, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + } + } + } + }, + "deep_copy": false +} \ No newline at end of file diff --git a/tests/integration/data/robot/expected.pipeline.json b/tests/integration/data/robot/expected.pipeline.json new file mode 100644 index 0000000..6137b76 --- /dev/null +++ b/tests/integration/data/robot/expected.pipeline.json @@ -0,0 +1,6841 @@ +{ + "id": "WYtzAK", + "predictions": { + "train": { + "name": "train", + "path": "pipeline/predictions/train.parquet" + }, + "validation": { + "name": "validation", + "path": "pipeline/predictions/validation.parquet" + }, + "test": { + "name": "test", + "path": "pipeline/predictions/test.parquet" + } + }, + "feature_sets": { + "train": { + "name": "features.train", + "path": "pipeline/feature_sets/features.train.parquet", + "profile": { + "f_x": { + "name": "f_x", + "role": "target", + "statistics": { + "count": 90, + "approx_unique": 75, + "avg": -10.733866666666666, + "min": -11.23, + "max": -10.39, + "q25": -10.852, + "q50": -10.706, + "q75": -10.632, + "std": 0.18424118291833055, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "f_y": { + "name": "f_y", + "role": "target", + "statistics": { + "count": 90, + "approx_unique": 67, + "avg": 6.4211588888888915, + "min": 5.95, + "max": 6.9718, + "q25": 6.2427, + "q50": 6.43725, + "q75": 6.59, + "std": 0.23847778305323794, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "f_z": { + "name": "f_z", + "role": "target", + "statistics": { + "count": 90, + "approx_unique": 61, + "avg": -7.6486744444444446, + "min": -7.99, + "max": -7.29, + "q25": -7.7033, + "q50": -7.641349999999999, + "q75": -7.61, + "std": 0.12120592891745888, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "feature_1_1": { + "name": "feature_1_1", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 83, + "avg": 0.3029163688055355, + "min": -0.31465415076773495, + "max": 0.7827058558842352, + "q25": 0.220330611723596, + "q50": 0.3249082843979988, + "q75": 0.38590252715777634, + "std": 0.16481064171623752, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_2": { + "name": "feature_1_2", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 91, + "avg": 0.011959457306833126, + "min": -0.48373951342150484, + "max": 0.2027935216787802, + "q25": -0.07795618058791894, + "q50": 0.035454099024066446, + "q75": 0.14938576206617865, + "std": 0.14943260045296886, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_3": { + "name": "feature_1_3", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 72, + "avg": 0.08407029635776446, + "min": -0.2704927088884153, + "max": 0.4940717531491363, + "q25": -0.03033782690797457, + "q50": 0.05748586711121888, + "q75": 0.2299577280967114, + "std": 0.17527049908816736, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_4": { + "name": "feature_1_4", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 46, + "avg": 0.25188956172160787, + "min": -0.23509573529982242, + "max": 0.5382123577854343, + "q25": 0.14343879457285652, + "q50": 0.2930111528134115, + "q75": 0.3550458832113746, + "std": 0.1812398668302307, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_5": { + "name": "feature_1_5", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 69, + "avg": 0.3927403093612645, + "min": 0.17607518464691357, + "max": 0.6725212867530115, + "q25": 0.31698847117353185, + "q50": 0.4038435104717734, + "q75": 0.4451822390825191, + "std": 0.11480776766812614, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_6": { + "name": "feature_1_6", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 69, + "avg": -0.09227228754178138, + "min": -0.4048465815826436, + "max": 0.098293559970952, + "q25": -0.21052389086715564, + "q50": -0.0685528452025958, + "q75": -0.002593265132116984, + "std": 0.1165370944586005, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_7": { + "name": "feature_1_7", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 62, + "avg": 1.2079429885282171, + "min": 0.8159451174374466, + "max": 1.5123557867430288, + "q25": 1.123353283261947, + "q50": 1.2223826534027085, + "q75": 1.2734256322534585, + "std": 0.11607311125787807, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_8": { + "name": "feature_1_8", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 89, + "avg": -0.045267897325640655, + "min": -0.39037741491000255, + "max": 0.1368375874054001, + "q25": -0.14116280017157984, + "q50": -0.02593470190059971, + "q75": 0.032217117912338666, + "std": 0.1107454364608701, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_9": { + "name": "feature_1_9", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 51, + "avg": 0.10811481047424647, + "min": -0.21980819819546835, + "max": 0.3258610834389272, + "q25": 0.033101174425396875, + "q50": 0.1224927800654327, + "q75": 0.1807290254159039, + "std": 0.09278593218207873, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_10": { + "name": "feature_1_10", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 91, + "avg": 0.12009873414329322, + "min": -0.19853987390199737, + "max": 0.31609433253497554, + "q25": 0.09362623703559955, + "q50": 0.12706491197836067, + "q75": 0.16441382269084, + "std": 0.08682787300981036, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_1": { + "name": "feature_2_1", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 77, + "avg": -0.47729084285094814, + "min": -1.0107945710816848, + "max": 0.0002537942929515135, + "q25": -0.6656841271245062, + "q50": -0.5199679586889386, + "q75": -0.29424806383550745, + "std": 0.24990550858449123, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_2": { + "name": "feature_2_2", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 81, + "avg": 0.02325322437330462, + "min": -0.4898249515041333, + "max": 0.5596788872673188, + "q25": -0.13757965076422, + "q50": 0.004578387908287743, + "q75": 0.24321247773407953, + "std": 0.2322925953111929, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_3": { + "name": "feature_2_3", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 90, + "avg": -0.3929188972604346, + "min": -0.950145815170969, + "max": -0.02296707125198176, + "q25": -0.515899447881892, + "q50": -0.3538856846165158, + "q75": -0.24813260903173434, + "std": 0.20085603094306023, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_4": { + "name": "feature_2_4", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 76, + "avg": -0.2727695078967271, + "min": -0.6477196351564702, + "max": 0.16378335384162102, + "q25": -0.38286019828756557, + "q50": -0.29568048528186175, + "q75": -0.15561341900220704, + "std": 0.17578182846904047, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_5": { + "name": "feature_2_5", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 73, + "avg": 0.14716625846389136, + "min": -0.17351283839885634, + "max": 0.5103964053629805, + "q25": 0.03499457552527253, + "q50": 0.1250140309126661, + "q75": 0.2257540196259104, + "std": 0.1503827430278282, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_6": { + "name": "feature_2_6", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 89, + "avg": -0.07527183787062067, + "min": -0.36892613642037103, + "max": 0.45334980309151224, + "q25": -0.19340741881525975, + "q50": -0.07342173104960995, + "q75": 0.025990090474862337, + "std": 0.15400346506978072, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_7": { + "name": "feature_2_7", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 56, + "avg": 2.0755824268813807, + "min": 1.7119138863476728, + "max": 2.5039235973072005, + "q25": 2.0015212936722104, + "q50": 2.065960158016336, + "q75": 2.1541396565925037, + "std": 0.15051918025560856, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_8": { + "name": "feature_2_8", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 87, + "avg": 0.00008866011991140269, + "min": -0.3411377235696948, + "max": 0.5151189655917409, + "q25": -0.1016487193985586, + "q50": -0.007322601493110977, + "q75": 0.08251932706319809, + "std": 0.15939682436221483, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_9": { + "name": "feature_2_9", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 39, + "avg": -7.441957950972197, + "min": -7.769466128030755, + "max": -7.214195121871735, + "q25": -7.496517156938319, + "q50": -7.409897130096453, + "q75": -7.360898515991032, + "std": 0.13135319135752388, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_10": { + "name": "feature_2_10", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 57, + "avg": -0.09360797138047791, + "min": -0.4306131483697273, + "max": 0.20935051577885525, + "q25": -0.18146524921654691, + "q50": -0.038237276962355835, + "q75": -0.017741479253866304, + "std": 0.140422650506953, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_1": { + "name": "feature_3_1", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 53, + "avg": -0.19424066283352154, + "min": -0.42962468282768174, + "max": 0.2583364066426611, + "q25": -0.26758642319762926, + "q50": -0.1837533599231441, + "q75": -0.15961375991220164, + "std": 0.10997469664193683, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_2": { + "name": "feature_3_2", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 74, + "avg": 0.16116088565306536, + "min": -0.17886279634534932, + "max": 0.4510687263935296, + "q25": 0.08558924388202038, + "q50": 0.1405825019304881, + "q75": 0.21673936496584525, + "std": 0.11008032539154326, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_3": { + "name": "feature_3_3", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 41, + "avg": -0.10600376901922601, + "min": -0.3742752151884578, + "max": 0.19878674657853865, + "q25": -0.13404160537759308, + "q50": -0.13384372883065127, + "q75": -0.06640058640152215, + "std": 0.09117236559678171, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_4": { + "name": "feature_3_4", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 39, + "avg": -0.1030715136653807, + "min": -0.42756259522132284, + "max": 0.11200664785622663, + "q25": -0.15991801391544605, + "q50": -0.10038447275439095, + "q75": -0.05095238102152804, + "std": 0.08877577656458578, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_5": { + "name": "feature_3_5", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 65, + "avg": -0.046826073151904346, + "min": -0.3058050102447669, + "max": 0.2682550750482219, + "q25": -0.1060823969560612, + "q50": -0.052241704717715165, + "q75": 0.0006932049804602974, + "std": 0.10017992474241678, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_6": { + "name": "feature_3_6", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 21, + "avg": -0.31550103434926957, + "min": -0.3685292971362771, + "max": 4.514633770863752e-16, + "q25": -0.3685292971362768, + "q50": -0.3160387001271303, + "q75": -0.28238497777218724, + "std": 0.07773440134663441, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_7": { + "name": "feature_3_7", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 68, + "avg": -0.3481756919057059, + "min": -0.5786182414067055, + "max": -0.034596193821641634, + "q25": -0.4076124397410062, + "q50": -0.35567043181015146, + "q75": -0.294052063651414, + "std": 0.09619705685778725, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_8": { + "name": "feature_3_8", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 44, + "avg": -0.09378414469456128, + "min": -0.41303397089738386, + "max": 0.210618903884933, + "q25": -0.12906911404610488, + "q50": -0.11831335454226283, + "q75": -0.04732534181690513, + "std": 0.0921549989239766, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_9": { + "name": "feature_3_9", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 62, + "avg": -0.2881041929800976, + "min": -0.43589553735072306, + "max": -0.0615262923916052, + "q25": -0.34668279051414164, + "q50": -0.29478310312967637, + "q75": -0.25626743180480765, + "std": 0.0862292982088366, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_10": { + "name": "feature_3_10", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 74, + "avg": -0.026348468239984452, + "min": -0.36225394997882004, + "max": 0.24685076123720567, + "q25": -0.09557927252938848, + "q50": -0.015733169682750348, + "q75": 0.024132284324813083, + "std": 0.08411080433688203, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "3": { + "name": "3", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 3.4097999999999993, + "min": 3.4098, + "max": 3.4098, + "q25": 3.4098, + "q50": 3.4098, + "q75": 3.4098, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "4": { + "name": "4", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -0.32736999999999933, + "min": -0.32737, + "max": -0.32737, + "q25": -0.32737, + "q50": -0.32737, + "q75": -0.32737, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "5": { + "name": "5", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.9604400000000006, + "min": 0.96044, + "max": 0.96044, + "q25": 0.96044, + "q50": 0.96044, + "q75": 0.96044, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "6": { + "name": "6", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -3.7435999999999985, + "min": -3.7436, + "max": -3.7436, + "q25": -3.7436, + "q50": -3.7436, + "q75": -3.7436, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "7": { + "name": "7", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -1.0190999999999992, + "min": -1.0191, + "max": -1.0191, + "q25": -1.0191, + "q50": -1.0191, + "q75": -1.0191, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "8": { + "name": "8", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -6.020500000000011, + "min": -6.0205, + "max": -6.0205, + "q25": -6.0205, + "q50": -6.0205, + "q75": -6.0205, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "9": { + "name": "9", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "10": { + "name": "10", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "11": { + "name": "11", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "12": { + "name": "12", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "13": { + "name": "13", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "14": { + "name": "14", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "15": { + "name": "15", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "16": { + "name": "16", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "17": { + "name": "17", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "18": { + "name": "18", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "19": { + "name": "19", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "20": { + "name": "20", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "21": { + "name": "21", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 8.380400000000014e-17, + "min": 8.3804e-17, + "max": 8.3804e-17, + "q25": 8.3804e-17, + "q50": 8.3804e-17, + "q75": 8.3804e-17, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "22": { + "name": "22", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -4.811599999999999, + "min": -4.8116, + "max": -4.8116, + "q25": -4.8116, + "q50": -4.8116, + "q75": -4.8116, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "23": { + "name": "23", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -1.4033000000000013, + "min": -1.4033, + "max": -1.4033, + "q25": -1.4033, + "q50": -1.4033, + "q75": -1.4033, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "24": { + "name": "24", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -0.13686000000000026, + "min": -0.13685999999999998, + "max": -0.13685999999999998, + "q25": -0.13685999999999998, + "q50": -0.13685999999999998, + "q75": -0.13685999999999998, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "25": { + "name": "25", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0024718999999999995, + "min": 0.0024719, + "max": 0.0024719, + "q25": 0.0024719, + "q50": 0.0024719, + "q75": 0.0024719, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "26": { + "name": "26", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "27": { + "name": "27", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 9.80270000000001e-16, + "min": 9.8027e-16, + "max": 9.8027e-16, + "q25": 9.8027e-16, + "q50": 9.8027e-16, + "q75": 9.8027e-16, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "28": { + "name": "28", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -55.64199999999992, + "min": -55.641999999999996, + "max": -55.641999999999996, + "q25": -55.641999999999996, + "q50": -55.641999999999996, + "q75": -55.641999999999996, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "29": { + "name": "29", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -16.311999999999976, + "min": -16.312, + "max": -16.312, + "q25": -16.312, + "q50": -16.312, + "q75": -16.312, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "30": { + "name": "30", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -1.2042, + "min": -1.2042, + "max": -1.2042, + "q25": -1.2042, + "q50": -1.2042, + "q75": -1.2042, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "31": { + "name": "31", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.021675000000000052, + "min": 0.021675, + "max": 0.021675, + "q25": 0.021675, + "q50": 0.021675, + "q75": 0.021675, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "32": { + "name": "32", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "33": { + "name": "33", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 2, + "avg": 3.4097933333333326, + "min": 3.4097, + "max": 3.4098, + "q25": 3.4098, + "q50": 3.4098, + "q75": 3.4098, + "std": 0.000025084128112200714, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "34": { + "name": "34", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 10, + "avg": -0.3273734444444442, + "min": -0.32742, + "max": -0.32733, + "q25": -0.32739, + "q50": -0.32737, + "q75": -0.32736, + "std": 0.000019554654672256435, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "35": { + "name": "35", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 7, + "avg": 0.9604327777777777, + "min": 0.9604, + "max": 0.96047, + "q25": 0.96042, + "q50": 0.96044, + "q75": 0.96045, + "std": 0.000017224739053348342, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "36": { + "name": "36", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 2, + "avg": -3.7436955555555502, + "min": -3.7437, + "max": -3.7436, + "q25": -3.7437, + "q50": -3.7437, + "q75": -3.7437, + "std": 0.00002072349321507661, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "37": { + "name": "37", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 2, + "avg": -1.0191022222222215, + "min": -1.0192, + "max": -1.0191, + "q25": -1.0191, + "q50": -1.0191, + "q75": -1.0191, + "std": 0.000014823135407909618, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "38": { + "name": "38", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -6.020500000000011, + "min": -6.0205, + "max": -6.0205, + "q25": -6.0205, + "q50": -6.0205, + "q75": -6.0205, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "39": { + "name": "39", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "40": { + "name": "40", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "41": { + "name": "41", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": -0.0, + "max": -0.0, + "q25": -0.0, + "q50": -0.0, + "q75": -0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "42": { + "name": "42", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "43": { + "name": "43", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "44": { + "name": "44", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "45": { + "name": "45", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 21, + "avg": 0.11991266666666668, + "min": 0.09863999999999999, + "max": 0.14795999999999998, + "q25": 0.11433, + "q50": 0.12105999999999999, + "q75": 0.12554, + "std": 0.009094154166276267, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "46": { + "name": "46", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 13, + "avg": -6.548282222222224, + "min": -6.5618, + "max": -6.5304, + "q25": -6.5551, + "q50": -6.5483, + "q75": -6.5438, + "std": 0.007198089287322413, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "47": { + "name": "47", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 17, + "avg": -2.815258888888891, + "min": -2.8404, + "max": -2.7888, + "q25": -2.8224, + "q50": -2.8135, + "q75": -2.8089999999999997, + "std": 0.00938972537254334, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "48": { + "name": "48", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 20, + "avg": -0.8301134444444447, + "min": -0.84335, + "max": -0.8113199999999999, + "q25": -0.8342, + "q50": -0.82962, + "q75": -0.82657, + "std": 0.006226257764926416, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "49": { + "name": "49", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 16, + "avg": 0.07021977777777792, + "min": 0.056427, + "max": 0.083877, + "q25": 0.067102, + "q50": 0.071677, + "q75": 0.074727, + "std": 0.0056365047695782315, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "50": { + "name": "50", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 21, + "avg": -0.1953428888888889, + "min": -0.21045999999999998, + "max": -0.17995, + "q25": -0.19977999999999999, + "q50": -0.19444499999999998, + "q75": -0.19063, + "std": 0.005854349625541456, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "51": { + "name": "51", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 4, + "avg": 0.12078599999999996, + "min": 0.10985, + "max": 0.12105999999999999, + "q25": 0.12105999999999999, + "q50": 0.12105999999999999, + "q75": 0.12105999999999999, + "std": 0.0015338991953753134, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "52": { + "name": "52", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -6.548299999999999, + "min": -6.5483, + "max": -6.5483, + "q25": -6.5483, + "q50": -6.5483, + "q75": -6.5483, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "53": { + "name": "53", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -2.815699999999998, + "min": -2.8157, + "max": -2.8157, + "q25": -2.8157, + "q50": -2.8157, + "q75": -2.8157, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "54": { + "name": "54", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 5, + "avg": -0.8298086666666671, + "min": -0.83267, + "max": -0.82657, + "q25": -0.83267, + "q50": -0.8281, + "q75": -0.8281, + "std": 0.002282677414742483, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "55": { + "name": "55", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 2, + "avg": 0.07018588888888903, + "min": 0.07015199999999999, + "max": 0.073202, + "q25": 0.07015199999999999, + "q50": 0.07015199999999999, + "q75": 0.07015199999999999, + "std": 0.00032149822878378714, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "56": { + "name": "56", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 5, + "avg": -0.19520744444444438, + "min": -0.19826, + "max": -0.19216, + "q25": -0.19826, + "q50": -0.19368, + "q75": -0.19368, + "std": 0.0022294185068984654, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "57": { + "name": "57", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 4, + "avg": 0.7699038888888889, + "min": 0.76989, + "max": 0.7699199999999999, + "q25": 0.7699, + "q50": 0.7699, + "q75": 0.76991, + "std": 6.982231774226693e-6, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "58": { + "name": "58", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 6, + "avg": 0.4100198888888888, + "min": 0.40998999999999997, + "max": 0.41003999999999996, + "q25": 0.41001000000000004, + "q50": 0.41002, + "q75": 0.41003, + "std": 0.000010546253868626157, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "59": { + "name": "59", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 48, + "avg": 0.08278952222222224, + "min": 0.082732, + "max": 0.082838, + "q25": 0.082776, + "q50": 0.08279, + "q75": 0.082802, + "std": 0.000018365960072599283, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "60": { + "name": "60", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 2, + "avg": -1.409378888888891, + "min": -1.4094, + "max": -1.4093, + "q25": -1.4094, + "q50": -1.4094, + "q75": -1.4094, + "std": 0.00004103833353067418, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "61": { + "name": "61", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 13, + "avg": 0.7859538888888887, + "min": 0.78589, + "max": 0.7860699999999999, + "q25": 0.78593, + "q50": 0.78595, + "q75": 0.78598, + "std": 0.00003175377335603696, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "62": { + "name": "62", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 12, + "avg": -0.36820477777777777, + "min": -0.36828, + "max": -0.36815, + "q25": -0.36822, + "q50": -0.36821, + "q75": -0.36818, + "std": 0.000025625995306625105, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "63": { + "name": "63", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "64": { + "name": "64", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "65": { + "name": "65", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "66": { + "name": "66", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "67": { + "name": "67", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "68": { + "name": "68", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "69": { + "name": "69", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 86, + "avg": -22.28985555555556, + "min": -24.633000000000003, + "max": -20.959, + "q25": -22.635, + "q50": -22.195, + "q75": -21.851999999999997, + "std": 0.6202698680723187, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "70": { + "name": "70", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 100, + "avg": -11.364411111111112, + "min": -12.285, + "max": -10.633, + "q25": -11.526, + "q50": -11.3455, + "q75": -11.142000000000001, + "std": 0.3142770514111636, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "71": { + "name": "71", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 92, + "avg": -18.554833333333338, + "min": -18.916, + "max": -18.05, + "q25": -18.679000000000002, + "q50": -18.5795, + "q75": -18.438, + "std": 0.18080868590550767, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "72": { + "name": "72", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 84, + "avg": -3.5600688888888885, + "min": -3.9265, + "max": -3.241, + "q25": -3.6194, + "q50": -3.5422000000000002, + "q75": -3.4936, + "std": 0.11474722061645332, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "73": { + "name": "73", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 81, + "avg": 5.840498888888888, + "min": 5.6508, + "max": 6.0109, + "q25": 5.7922, + "q50": 5.8383, + "q75": 5.8821, + "std": 0.07474927303309553, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "74": { + "name": "74", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 85, + "avg": -1.9630522222222215, + "min": -2.167, + "max": -1.7896, + "q25": -2.0301, + "q50": -1.95795, + "q75": -1.9001, + "std": 0.08460407357018439, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "75": { + "name": "75", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.7699000000000005, + "min": 0.7699, + "max": 0.7699, + "q25": 0.7699, + "q50": 0.7699, + "q75": 0.7699, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "76": { + "name": "76", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.4100399999999998, + "min": 0.41003999999999996, + "max": 0.41003999999999996, + "q25": 0.41003999999999996, + "q50": 0.41003999999999996, + "q75": 0.41003999999999996, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "77": { + "name": "77", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.08278199999999993, + "min": 0.08278200000000001, + "max": 0.08278200000000001, + "q25": 0.08278200000000001, + "q50": 0.08278200000000001, + "q75": 0.08278200000000001, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "78": { + "name": "78", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -1.4094000000000022, + "min": -1.4094, + "max": -1.4094, + "q25": -1.4094, + "q50": -1.4094, + "q75": -1.4094, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "79": { + "name": "79", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.7860000000000009, + "min": 0.7859999999999999, + "max": 0.7859999999999999, + "q25": 0.7859999999999999, + "q50": 0.7859999999999999, + "q75": 0.7859999999999999, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "80": { + "name": "80", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": -0.3681300000000005, + "min": -0.36813, + "max": -0.36813, + "q25": -0.36813, + "q50": -0.36813, + "q75": -0.36813, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "81": { + "name": "81", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "82": { + "name": "82", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "83": { + "name": "83", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "84": { + "name": "84", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "85": { + "name": "85", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "86": { + "name": "86", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "98": { + "name": "98", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 2, + "avg": 48.053000000000004, + "min": 48.00899999999999, + "max": 48.068999999999996, + "q25": 48.00899999999999, + "q50": 48.068999999999996, + "q75": 48.068999999999996, + "std": 0.026681643734216377, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "99": { + "name": "99", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 2, + "avg": 48.02033333333333, + "min": 48.00899999999999, + "max": 48.068999999999996, + "q25": 48.00899999999999, + "q50": 48.00899999999999, + "q75": 48.00899999999999, + "std": 0.023616790827478015, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "100": { + "name": "100", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 7, + "avg": 0.906720666666667, + "min": 0.78776, + "max": 1.11, + "q25": 0.8593799999999999, + "q50": 0.89518, + "q75": 0.93099, + "std": 0.05030257533112812, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "101": { + "name": "101", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 6, + "avg": 47.85533333333337, + "min": 47.818000000000005, + "max": 47.895, + "q25": 47.849, + "q50": 47.849, + "q75": 47.864, + "std": 0.022072403839090607, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "102": { + "name": "102", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 5, + "avg": 47.898644444444464, + "min": 47.864, + "max": 47.925, + "q25": 47.879, + "q50": 47.895, + "q75": 47.925, + "std": 0.021592919725505744, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "103": { + "name": "103", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 3, + "avg": 47.801333333333375, + "min": 47.788000000000004, + "max": 47.818000000000005, + "q25": 47.788000000000004, + "q50": 47.803000000000004, + "q75": 47.818000000000005, + "std": 0.013196867180159553, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "104": { + "name": "104", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 4, + "avg": 47.830166666666635, + "min": 47.803000000000004, + "max": 47.849, + "q25": 47.818000000000005, + "q50": 47.833999999999996, + "q75": 47.833999999999996, + "std": 0.014095381345705139, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "105": { + "name": "105", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 4, + "avg": 47.95866666666665, + "min": 47.94, + "max": 47.986000000000004, + "q25": 47.955, + "q50": 47.955, + "q75": 47.971000000000004, + "std": 0.014229262458485287, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "106": { + "name": "106", + "role": "numerical", + "statistics": { + "count": 90, + "approx_unique": 3, + "avg": 47.96328888888889, + "min": 47.94, + "max": 47.971000000000004, + "q25": 47.955, + "q50": 47.971000000000004, + "q75": 47.971000000000004, + "std": 0.010811193163940106, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + } + } + }, + "validation": { + "name": "features.validation", + "path": "pipeline/feature_sets/features.validation.parquet", + "profile": { + "f_x": { + "name": "f_x", + "role": "target", + "statistics": { + "count": 30, + "approx_unique": 32, + "avg": -10.5642, + "min": -10.932, + "max": -10.06, + "q25": -10.71, + "q50": -10.575500000000002, + "q75": -10.447000000000001, + "std": 0.23268054169345292, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "f_y": { + "name": "f_y", + "role": "target", + "statistics": { + "count": 30, + "approx_unique": 26, + "avg": 6.4535, + "min": 5.93, + "max": 6.7792, + "q25": 6.35, + "q50": 6.4831, + "q75": 6.56, + "std": 0.21875581253361343, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "f_z": { + "name": "f_z", + "role": "target", + "statistics": { + "count": 30, + "approx_unique": 27, + "avg": -7.461039999999999, + "min": -7.66, + "max": -7.2267, + "q25": -7.54, + "q50": -7.48, + "q75": -7.3936, + "std": 0.11093529832200898, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "feature_1_1": { + "name": "feature_1_1", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 24, + "avg": 0.19332420441436537, + "min": -0.06930364540062461, + "max": 1.3037535132510685, + "q25": 0.10877551166374869, + "q50": 0.14291324555132306, + "q75": 0.24721962075109202, + "std": 0.22649552097283404, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_2": { + "name": "feature_1_2", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 18, + "avg": -0.24948452825416273, + "min": -0.4664868527180687, + "max": -0.008751983051116944, + "q25": -0.31799457554536276, + "q50": -0.2487903780085609, + "q75": -0.1959040018260866, + "std": 0.09273869760797071, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_3": { + "name": "feature_1_3", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 33, + "avg": -0.03220946094021907, + "min": -0.5107104892437428, + "max": 0.33288120717118047, + "q25": -0.2172751209655467, + "q50": 0.00014504147973003895, + "q75": 0.1316464123291316, + "std": 0.23310081717400694, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_4": { + "name": "feature_1_4", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 19, + "avg": 0.08732083783309112, + "min": -0.10287030322377438, + "max": 0.17187940863731502, + "q25": 0.0802961713502851, + "q50": 0.08029617135028516, + "q75": 0.09118402694709957, + "std": 0.05114212039632681, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_5": { + "name": "feature_1_5", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 27, + "avg": 0.07948716255068788, + "min": -0.10932380846978837, + "max": 0.26991479552895076, + "q25": 0.02027685767130518, + "q50": 0.07208644575746953, + "q75": 0.10782668921811735, + "std": 0.08845071646577753, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_6": { + "name": "feature_1_6", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 24, + "avg": -0.18233280354848666, + "min": -0.4827235133296347, + "max": 0.1358070895207469, + "q25": -0.3501716646872001, + "q50": -0.21407185345596058, + "q75": -0.02388809656338143, + "std": 0.19310740054288641, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_7": { + "name": "feature_1_7", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 28, + "avg": 1.0641570740696455, + "min": 0.777644136584092, + "max": 1.2448605057965791, + "q25": 0.9969938283998551, + "q50": 1.0680944411361768, + "q75": 1.1700734819881216, + "std": 0.11858626770232168, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_8": { + "name": "feature_1_8", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 27, + "avg": -0.1551730746013871, + "min": -0.473075626179459, + "max": 0.10310515928743302, + "q25": -0.3076792036405461, + "q50": -0.14625013307001683, + "q75": -0.03407518465416763, + "std": 0.16971366251454276, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_9": { + "name": "feature_1_9", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 4, + "avg": 0.15834076564615415, + "min": 0.033101174425396875, + "max": 1.8107382662249447, + "q25": 0.033101174425396875, + "q50": 0.033101174425396875, + "q75": 0.033101174425396875, + "std": 0.40069341721501156, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_10": { + "name": "feature_1_10", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 27, + "avg": 0.10901962726390516, + "min": -0.08377860442841095, + "max": 0.2605343481036355, + "q25": 0.037694921761370584, + "q50": 0.10697378018021675, + "q75": 0.16899039675248545, + "std": 0.08159971392741276, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_1": { + "name": "feature_2_1", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 21, + "avg": -1.0453845647173199, + "min": -1.3460824965880067, + "max": -0.6735719458851226, + "q25": -1.2264781350235527, + "q50": -1.0286035881182158, + "q75": -0.8803244767013989, + "std": 0.20481309067880235, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_2": { + "name": "feature_2_2", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 15, + "avg": -0.5661851957649622, + "min": -0.8187028842777508, + "max": -0.22545488552981147, + "q25": -0.6281239921815214, + "q50": -0.5648414652788843, + "q75": -0.5257859905450427, + "std": 0.1487310558710614, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_3": { + "name": "feature_2_3", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 21, + "avg": -0.41623350214906585, + "min": -0.7696245032865708, + "max": -0.014361416902144361, + "q25": -0.5204723129394887, + "q50": -0.38996440289319434, + "q75": -0.34533151657601335, + "std": 0.16155216436175804, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_4": { + "name": "feature_2_4", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 18, + "avg": -0.2978326158779928, + "min": -0.5050112572399559, + "max": 0.028664635281663388, + "q25": -0.5050112572399557, + "q50": -0.22089972352325732, + "q75": -0.16620112071181375, + "std": 0.16352894948978416, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_5": { + "name": "feature_2_5", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 23, + "avg": 0.0409853052121245, + "min": -0.12182810138649722, + "max": 0.5423670291968665, + "q25": -0.037345855270531525, + "q50": 0.0407825927700286, + "q75": 0.09142159288139813, + "std": 0.12110415920479999, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_6": { + "name": "feature_2_6", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 25, + "avg": -0.2055093204130946, + "min": -0.4627830029525615, + "max": 0.35934682649676397, + "q25": -0.34921990974190326, + "q50": -0.22179819211792431, + "q75": -0.09406641645971225, + "std": 0.17840704413673253, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_7": { + "name": "feature_2_7", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 19, + "avg": 2.142361172203464, + "min": 1.7685768462687088, + "max": 2.570489509920782, + "q25": 1.928420152157406, + "q50": 2.190929511201602, + "q75": 2.3007878576168435, + "std": 0.22293632391972465, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_8": { + "name": "feature_2_8", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 23, + "avg": -0.06373529289250557, + "min": -0.4231871228845855, + "max": 0.27229675050865815, + "q25": -0.2648903580406863, + "q50": -0.05703426232304057, + "q75": 0.09012103816953052, + "std": 0.20660065875996825, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_9": { + "name": "feature_2_9", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 18, + "avg": -7.643093988399562, + "min": -8.050995225861147, + "max": -7.409897130096452, + "q25": -7.769466128030757, + "q50": -7.6641613370213175, + "q75": -7.473070550207218, + "std": 0.15778718235301686, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_10": { + "name": "feature_2_10", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 27, + "avg": -0.7530513784013607, + "min": -1.3387934288398122, + "max": -0.20416046725912887, + "q25": -0.9437793926177869, + "q50": -0.7563854503126777, + "q75": -0.5573693981246907, + "std": 0.31863069066844263, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_1": { + "name": "feature_3_1", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 3, + "avg": -0.13134804308484582, + "min": -0.15961375991220164, + "max": -0.0024689568783826856, + "q25": -0.15961375991220164, + "q50": -0.15961375991220164, + "q75": -0.07326042218884443, + "std": 0.04563013152071064, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_2": { + "name": "feature_3_2", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 17, + "avg": 0.1496585775117086, + "min": 0.058092614857786516, + "max": 0.3560530253389044, + "q25": 0.08884513685475545, + "q50": 0.12479216629262262, + "q75": 0.19222745792740756, + "std": 0.07679729757155859, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_3": { + "name": "feature_3_3", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 7, + "avg": -0.15198687814246747, + "min": -0.35791488516837033, + "max": 0.07389933055073145, + "q25": -0.13404160537759308, + "q50": -0.13404160537759308, + "q75": -0.13404160537759308, + "std": 0.0864736053500799, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_4": { + "name": "feature_3_4", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 5, + "avg": -0.11632438554282588, + "min": -0.20960742932896942, + "max": 0.010684053390404269, + "q25": -0.15991801391544605, + "q50": -0.15991801391544605, + "q75": -0.10038447275439095, + "std": 0.06247110544464339, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_5": { + "name": "feature_3_5", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 26, + "avg": -0.0984510164977664, + "min": -0.34489103667245363, + "max": 0.2165068431882982, + "q25": -0.17679314360030832, + "q50": -0.11103071738897047, + "q75": -0.013643570961072231, + "std": 0.13788035215100206, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_6": { + "name": "feature_3_6", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -0.36852929713627697, + "min": -0.3685292971362768, + "max": -0.3685292971362768, + "q25": -0.3685292971362768, + "q50": -0.3685292971362768, + "q75": -0.3685292971362768, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_7": { + "name": "feature_3_7", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 13, + "avg": -0.4439899096092964, + "min": -0.5352447770470662, + "max": -0.33798482353938075, + "q25": -0.472935651303822, + "q50": -0.44312172002842065, + "q75": -0.4183878615399482, + "std": 0.05295072766278327, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_8": { + "name": "feature_3_8", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 3, + "avg": -0.11044296854216397, + "min": -0.13463080278231188, + "max": 0.01896951033776234, + "q25": -0.12906911404610488, + "q50": -0.12906911404610488, + "q75": -0.12906911404610488, + "std": 0.0516751566527303, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_9": { + "name": "feature_3_9", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 18, + "avg": -0.3792580928351808, + "min": -0.5013261748674661, + "max": -0.2537691424216535, + "q25": -0.4291295077195588, + "q50": -0.3981624767174681, + "q75": -0.36719544571537716, + "std": 0.060455838588677244, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_10": { + "name": "feature_3_10", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 20, + "avg": 0.022939542302922975, + "min": -0.0755313506940955, + "max": 0.1304724724615783, + "q25": -0.03566589668653207, + "q50": 0.04406501132859475, + "q75": 0.06399773833237647, + "std": 0.05775911514165324, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "3": { + "name": "3", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 3.409800000000001, + "min": 3.4098, + "max": 3.4098, + "q25": 3.4098, + "q50": 3.4098, + "q75": 3.4098, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "4": { + "name": "4", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -0.3273700000000001, + "min": -0.32737, + "max": -0.32737, + "q25": -0.32737, + "q50": -0.32737, + "q75": -0.32737, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "5": { + "name": "5", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.9604399999999994, + "min": 0.96044, + "max": 0.96044, + "q25": 0.96044, + "q50": 0.96044, + "q75": 0.96044, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "6": { + "name": "6", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -3.7436000000000003, + "min": -3.7436, + "max": -3.7436, + "q25": -3.7436, + "q50": -3.7436, + "q75": -3.7436, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "7": { + "name": "7", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -1.0191000000000008, + "min": -1.0191, + "max": -1.0191, + "q25": -1.0191, + "q50": -1.0191, + "q75": -1.0191, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "8": { + "name": "8", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -6.020499999999999, + "min": -6.0205, + "max": -6.0205, + "q25": -6.0205, + "q50": -6.0205, + "q75": -6.0205, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "9": { + "name": "9", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "10": { + "name": "10", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "11": { + "name": "11", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "12": { + "name": "12", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "13": { + "name": "13", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "14": { + "name": "14", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "15": { + "name": "15", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "16": { + "name": "16", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "17": { + "name": "17", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "18": { + "name": "18", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "19": { + "name": "19", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "20": { + "name": "20", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "21": { + "name": "21", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 8.380399999999998e-17, + "min": 8.3804e-17, + "max": 8.3804e-17, + "q25": 8.3804e-17, + "q50": 8.3804e-17, + "q75": 8.3804e-17, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "22": { + "name": "22", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -4.811599999999999, + "min": -4.8116, + "max": -4.8116, + "q25": -4.8116, + "q50": -4.8116, + "q75": -4.8116, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "23": { + "name": "23", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -1.4033000000000009, + "min": -1.4033, + "max": -1.4033, + "q25": -1.4033, + "q50": -1.4033, + "q75": -1.4033, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "24": { + "name": "24", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -0.13685999999999998, + "min": -0.13685999999999998, + "max": -0.13685999999999998, + "q25": -0.13685999999999998, + "q50": -0.13685999999999998, + "q75": -0.13685999999999998, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "25": { + "name": "25", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0024718999999999995, + "min": 0.0024719, + "max": 0.0024719, + "q25": 0.0024719, + "q50": 0.0024719, + "q75": 0.0024719, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "26": { + "name": "26", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "27": { + "name": "27", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 9.802700000000004e-16, + "min": 9.8027e-16, + "max": 9.8027e-16, + "q25": 9.8027e-16, + "q50": 9.8027e-16, + "q75": 9.8027e-16, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "28": { + "name": "28", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -55.64200000000003, + "min": -55.641999999999996, + "max": -55.641999999999996, + "q25": -55.641999999999996, + "q50": -55.641999999999996, + "q75": -55.641999999999996, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "29": { + "name": "29", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -16.31200000000001, + "min": -16.312, + "max": -16.312, + "q25": -16.312, + "q50": -16.312, + "q75": -16.312, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "30": { + "name": "30", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -1.2042, + "min": -1.2042, + "max": -1.2042, + "q25": -1.2042, + "q50": -1.2042, + "q75": -1.2042, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "31": { + "name": "31", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.021675, + "min": 0.021675, + "max": 0.021675, + "q25": 0.021675, + "q50": 0.021675, + "q75": 0.021675, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "32": { + "name": "32", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "33": { + "name": "33", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 3.4097866666666676, + "min": 3.4097, + "max": 3.4098, + "q25": 3.4098, + "q50": 3.4098, + "q75": 3.4098, + "std": 0.000034574590364305684, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "34": { + "name": "34", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 7, + "avg": -0.3273783333333332, + "min": -0.32741, + "max": -0.32734, + "q25": -0.3274, + "q50": -0.32737, + "q75": -0.32736, + "std": 0.000020356026530054445, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "35": { + "name": "35", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 5, + "avg": 0.9604276666666665, + "min": 0.9604, + "max": 0.96045, + "q25": 0.96042, + "q50": 0.96042, + "q75": 0.96044, + "std": 0.000015465943304497223, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "36": { + "name": "36", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -3.743700000000001, + "min": -3.7437, + "max": -3.7437, + "q25": -3.7437, + "q50": -3.7437, + "q75": -3.7437, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "37": { + "name": "37", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": -1.019103333333334, + "min": -1.0192, + "max": -1.0191, + "q25": -1.0191, + "q50": -1.0191, + "q75": -1.0191, + "std": 0.0000182574185835436, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "38": { + "name": "38", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -6.020499999999999, + "min": -6.0205, + "max": -6.0205, + "q25": -6.0205, + "q50": -6.0205, + "q75": -6.0205, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "39": { + "name": "39", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "40": { + "name": "40", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "41": { + "name": "41", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": -0.0, + "max": -0.0, + "q25": -0.0, + "q50": -0.0, + "q75": -0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "42": { + "name": "42", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "43": { + "name": "43", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "44": { + "name": "44", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "45": { + "name": "45", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 16, + "avg": 0.123375, + "min": 0.09863999999999999, + "max": 0.13899, + "q25": 0.11882000000000001, + "q50": 0.12442, + "q75": 0.13003, + "std": 0.009410180015867632, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "46": { + "name": "46", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 11, + "avg": -6.548706666666667, + "min": -6.5685, + "max": -6.5371, + "q25": -6.5551, + "q50": -6.5483, + "q75": -6.5416, + "std": 0.007517975393880323, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "47": { + "name": "47", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 11, + "avg": -2.8156400000000006, + "min": -2.8292, + "max": -2.8023, + "q25": -2.8202, + "q50": -2.8157, + "q75": -2.8089999999999997, + "std": 0.0075047846806852985, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "48": { + "name": "48", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 16, + "avg": -0.8293686666666668, + "min": -0.8418200000000001, + "max": -0.81742, + "q25": -0.83267, + "q50": -0.8281, + "q75": -0.82505, + "std": 0.005721133679150738, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "49": { + "name": "49", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 13, + "avg": 0.06994866666666667, + "min": 0.059476999999999995, + "max": 0.079302, + "q25": 0.065577, + "q50": 0.068627, + "q75": 0.073202, + "std": 0.005077370065458026, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "50": { + "name": "50", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 15, + "avg": -0.19703766666666664, + "min": -0.20893, + "max": -0.18758, + "q25": -0.20131, + "q50": -0.19673, + "q75": -0.19216, + "std": 0.005423127792839781, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "51": { + "name": "51", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.11881999999999995, + "min": 0.11882000000000001, + "max": 0.11882000000000001, + "q25": 0.11882000000000001, + "q50": 0.11882000000000001, + "q75": 0.11882000000000001, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "52": { + "name": "52", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -6.548300000000003, + "min": -6.5483, + "max": -6.5483, + "q25": -6.5483, + "q50": -6.5483, + "q75": -6.5483, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "53": { + "name": "53", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -2.8157000000000014, + "min": -2.8157, + "max": -2.8157, + "q25": -2.8157, + "q50": -2.8157, + "q75": -2.8157, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "54": { + "name": "54", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 5, + "avg": -0.8296739999999997, + "min": -0.83267, + "max": -0.82657, + "q25": -0.83267, + "q50": -0.8281, + "q75": -0.8281, + "std": 0.0020978159414348323, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "55": { + "name": "55", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.070152, + "min": 0.07015199999999999, + "max": 0.07015199999999999, + "q25": 0.07015199999999999, + "q50": 0.07015199999999999, + "q75": 0.07015199999999999, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "56": { + "name": "56", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 5, + "avg": -0.19673366666666656, + "min": -0.19826, + "max": -0.19216, + "q25": -0.19826, + "q50": -0.19826, + "q75": -0.19521, + "std": 0.0020824959880465267, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "57": { + "name": "57", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 5, + "avg": 0.7699036666666664, + "min": 0.76988, + "max": 0.7699199999999999, + "q25": 0.7699, + "q50": 0.7699, + "q75": 0.76991, + "std": 8.899179866617674e-6, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "58": { + "name": "58", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 7, + "avg": 0.4100196666666667, + "min": 0.40998999999999997, + "max": 0.41005, + "q25": 0.41001000000000004, + "q50": 0.41002, + "q75": 0.41003, + "std": 0.000013514572807192662, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "59": { + "name": "59", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 28, + "avg": 0.08279593333333332, + "min": 0.08276900000000001, + "max": 0.082833, + "q25": 0.08278200000000001, + "q50": 0.082794, + "q75": 0.08281000000000001, + "std": 0.00001697042728686539, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "60": { + "name": "60", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": -1.4093799999999999, + "min": -1.4094, + "max": -1.4093, + "q25": -1.4094, + "q50": -1.4094, + "q75": -1.4094, + "std": 0.00004068381021720471, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "61": { + "name": "61", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 10, + "avg": 0.7859436666666667, + "min": 0.78588, + "max": 0.78601, + "q25": 0.78592, + "q50": 0.78594, + "q75": 0.78596, + "std": 0.000030112814700618006, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "62": { + "name": "62", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 11, + "avg": -0.3682093333333333, + "min": -0.36826, + "max": -0.36815, + "q25": -0.36823, + "q50": -0.3682, + "q75": -0.36819, + "std": 0.000029117281671781178, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "63": { + "name": "63", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "64": { + "name": "64", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "65": { + "name": "65", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "66": { + "name": "66", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "67": { + "name": "67", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "68": { + "name": "68", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "69": { + "name": "69", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 28, + "avg": -22.26903333333333, + "min": -23.305, + "max": -21.339000000000002, + "q25": -22.645, + "q50": -22.258499999999998, + "q75": -21.991, + "std": 0.5447219780156962, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "70": { + "name": "70", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 30, + "avg": -11.434133333333332, + "min": -12.095, + "max": -10.603, + "q25": -11.642999999999999, + "q50": -11.4335, + "q75": -11.258, + "std": 0.32464003761549265, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "71": { + "name": "71", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 24, + "avg": -18.563200000000002, + "min": -19.077, + "max": -18.233, + "q25": -18.702, + "q50": -18.512999999999998, + "q75": -18.447, + "std": 0.1988744882305561, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "72": { + "name": "72", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 29, + "avg": -3.5288433333333336, + "min": -3.7051, + "max": -3.2735, + "q25": -3.5982, + "q50": -3.56235, + "q75": -3.4771, + "std": 0.10279882155279635, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "73": { + "name": "73", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 31, + "avg": 5.842810000000001, + "min": 5.7124, + "max": 5.9927, + "q25": 5.7869, + "q50": 5.84455, + "q75": 5.8891, + "std": 0.06915108072559123, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "74": { + "name": "74", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 32, + "avg": -1.9544200000000003, + "min": -2.1053, + "max": -1.8188, + "q25": -2.0024, + "q50": -1.9617, + "q75": -1.9151, + "std": 0.06628655868325775, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "75": { + "name": "75", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.7698999999999999, + "min": 0.7699, + "max": 0.7699, + "q25": 0.7699, + "q50": 0.7699, + "q75": 0.7699, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "76": { + "name": "76", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.41004000000000024, + "min": 0.41003999999999996, + "max": 0.41003999999999996, + "q25": 0.41003999999999996, + "q50": 0.41003999999999996, + "q75": 0.41003999999999996, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "77": { + "name": "77", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.08278199999999995, + "min": 0.08278200000000001, + "max": 0.08278200000000001, + "q25": 0.08278200000000001, + "q50": 0.08278200000000001, + "q75": 0.08278200000000001, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "78": { + "name": "78", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -1.4094000000000002, + "min": -1.4094, + "max": -1.4094, + "q25": -1.4094, + "q50": -1.4094, + "q75": -1.4094, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "79": { + "name": "79", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.7860000000000001, + "min": 0.7859999999999999, + "max": 0.7859999999999999, + "q25": 0.7859999999999999, + "q50": 0.7859999999999999, + "q75": 0.7859999999999999, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "80": { + "name": "80", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -0.3681300000000001, + "min": -0.36813, + "max": -0.36813, + "q25": -0.36813, + "q50": -0.36813, + "q75": -0.36813, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "81": { + "name": "81", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "82": { + "name": "82", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "83": { + "name": "83", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "84": { + "name": "84", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "85": { + "name": "85", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "86": { + "name": "86", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "98": { + "name": "98", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 48.054999999999986, + "min": 48.00899999999999, + "max": 48.068999999999996, + "q25": 48.068999999999996, + "q50": 48.068999999999996, + "q75": 48.068999999999996, + "std": 0.025810984029125853, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "99": { + "name": "99", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 48.01300000000001, + "min": 48.00899999999999, + "max": 48.068999999999996, + "q25": 48.00899999999999, + "q50": 48.00899999999999, + "q75": 48.00899999999999, + "std": 0.015222487902148182, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "100": { + "name": "100", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 6, + "avg": 0.9095060000000003, + "min": 0.8593799999999999, + "max": 1.0384, + "q25": 0.8593799999999999, + "q50": 0.89518, + "q75": 0.93099, + "std": 0.05115782709521046, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "101": { + "name": "101", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 47.85499999999999, + "min": 47.849, + "max": 47.864, + "q25": 47.849, + "q50": 47.849, + "q75": 47.864, + "std": 0.007474093186834875, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "102": { + "name": "102", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 3, + "avg": 47.891733333333335, + "min": 47.879, + "max": 47.91, + "q25": 47.879, + "q50": 47.895, + "q75": 47.895, + "std": 0.008665959299163157, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "103": { + "name": "103", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 3, + "avg": 47.793, + "min": 47.773, + "max": 47.818000000000005, + "q25": 47.773, + "q50": 47.788000000000004, + "q75": 47.818000000000005, + "std": 0.019028109877683497, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "104": { + "name": "104", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 47.82866666666668, + "min": 47.818000000000005, + "max": 47.833999999999996, + "q25": 47.818000000000005, + "q50": 47.833999999999996, + "q75": 47.833999999999996, + "std": 0.007671412823760338, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "105": { + "name": "105", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 47.96193333333334, + "min": 47.955, + "max": 47.971000000000004, + "q25": 47.955, + "q50": 47.955, + "q75": 47.971000000000004, + "std": 0.008064110927902024, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "106": { + "name": "106", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 47.960333333333324, + "min": 47.955, + "max": 47.971000000000004, + "q25": 47.955, + "q50": 47.955, + "q75": 47.971000000000004, + "std": 0.007671412823770011, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + } + } + }, + "test": { + "name": "features.test", + "path": "pipeline/feature_sets/features.test.parquet", + "profile": { + "f_x": { + "name": "f_x", + "role": "target", + "statistics": { + "count": 30, + "approx_unique": 26, + "avg": -10.919066666666668, + "min": -11.28, + "max": -10.503, + "q25": -11.092, + "q50": -10.930499999999999, + "q75": -10.720999999999998, + "std": 0.21154520725519532, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "f_y": { + "name": "f_y", + "role": "target", + "statistics": { + "count": 30, + "approx_unique": 26, + "avg": 6.5138, + "min": 5.93, + "max": 6.83, + "q25": 6.4475, + "q50": 6.57335, + "q75": 6.63, + "std": 0.21305850095123235, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "f_z": { + "name": "f_z", + "role": "target", + "statistics": { + "count": 30, + "approx_unique": 30, + "avg": -7.708129999999998, + "min": -7.89, + "max": -7.48, + "q25": -7.77, + "q50": -7.7212, + "q75": -7.6182, + "std": 0.10587867210584265, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "target" + } + }, + "feature_1_1": { + "name": "feature_1_1", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 25, + "avg": 0.1524093562359838, + "min": -0.06230057569151897, + "max": 0.25400403786183595, + "q25": 0.10218410482770521, + "q50": 0.15984646375779327, + "q75": 0.20339739351712569, + "std": 0.0706293760823357, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_2": { + "name": "feature_1_2", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 21, + "avg": 0.03241664953586977, + "min": -0.29239587203981093, + "max": 0.23128641190632715, + "q25": -0.07795618058791894, + "q50": 0.04413439313135731, + "q75": 0.1006685270806223, + "std": 0.1279342283722369, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_3": { + "name": "feature_1_3", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 23, + "avg": -0.43253947351574656, + "min": -0.7587194442079126, + "max": 0.1432710290186659, + "q25": -0.5863556326788111, + "q50": -0.4596460783923007, + "q75": -0.39242367993705063, + "std": 0.24088395202452934, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_4": { + "name": "feature_1_4", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 15, + "avg": 0.04567194367173819, + "min": -0.23509573529982242, + "max": 0.4466291204984043, + "q25": -0.10287030322377441, + "q50": 0.016349979410628174, + "q75": 0.14343879457285652, + "std": 0.17580667325784777, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_5": { + "name": "feature_1_5", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 28, + "avg": 0.12023417368176141, + "min": -0.10932380846978833, + "max": 0.46135286868736036, + "q25": -0.002472640804960291, + "q50": 0.09585168094504876, + "q75": 0.24087551771746007, + "std": 0.16892188587797324, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_6": { + "name": "feature_1_6", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 24, + "avg": -0.4166301888270923, + "min": -0.7796393920510681, + "max": -0.03525080894104533, + "q25": -0.4827235133296348, + "q50": -0.4128996264196124, + "q75": -0.3117040267141978, + "std": 0.16347572033952537, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_7": { + "name": "feature_1_7", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 25, + "avg": 0.918130347325347, + "min": 0.6486824075950116, + "max": 1.121470461434972, + "q25": 0.8279860204915113, + "q50": 0.9228435555856194, + "q75": 1.0715823980594366, + "std": 0.14842298685041855, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_8": { + "name": "feature_1_8", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 27, + "avg": -0.3567050935918786, + "min": -0.7383477819169229, + "max": 0.030083152675448463, + "q25": -0.5201083655588954, + "q50": -0.32224620438195983, + "q75": -0.18380999726655428, + "std": 0.2002888273859639, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_9": { + "name": "feature_1_9", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 13, + "avg": 0.05829206339795194, + "min": -0.2198081981954684, + "max": 0.17948112893216206, + "q25": 0.02136291128631709, + "q50": 0.033101174425396875, + "q75": 0.1224927800654327, + "std": 0.09523495287817127, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_1_10": { + "name": "feature_1_10", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 26, + "avg": 0.12940802492939402, + "min": -0.19164798475819547, + "max": 0.21368313059326913, + "q25": 0.11547783809699005, + "q50": 0.13339141188119694, + "q75": 0.1690762967787726, + "std": 0.07265840413281201, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_1": { + "name": "feature_2_1", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 15, + "avg": -0.49923308197242283, + "min": -1.3881557621548986, + "max": -0.05066862814291171, + "q25": -0.5681504314032737, + "q50": -0.4404320352041622, + "q75": -0.29391849229971095, + "std": 0.3208253139015117, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_2": { + "name": "feature_2_2", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 24, + "avg": 0.16156751192846977, + "min": 0.004179481300259469, + "max": 0.48849840893503926, + "q25": 0.004179481300259583, + "q50": 0.0674620082028966, + "q75": 0.2970963750329675, + "std": 0.15409976759311245, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_3": { + "name": "feature_2_3", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 24, + "avg": -0.5107909840373824, + "min": -0.7696245032865707, + "max": -0.2667919647640081, + "q25": -0.6080427111212263, + "q50": -0.5204723129394886, + "q75": -0.3899644028931944, + "std": 0.12330020337005919, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_4": { + "name": "feature_2_4", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 17, + "avg": -0.22393787099431764, + "min": -0.34112747590422793, + "max": -0.08158031589641734, + "q25": -0.2978669247716409, + "q50": -0.28705178698849426, + "q75": -0.11235286786962002, + "std": 0.09662384468603932, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_5": { + "name": "feature_2_5", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 19, + "avg": 0.563274819619861, + "min": 0.24173017217448634, + "max": 0.8464391786647661, + "q25": 0.4858244020463106, + "q50": 0.5754017572824353, + "q75": 0.6091610906900148, + "std": 0.1265117123901637, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_6": { + "name": "feature_2_6", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 24, + "avg": 0.08817291239996682, + "min": -0.07347628465893369, + "max": 0.4224675844127627, + "q25": 0.027412720057165496, + "q50": 0.08422672772450158, + "q75": 0.13447072817772077, + "std": 0.0988765069914432, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_7": { + "name": "feature_2_7", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 24, + "avg": 2.2127116188096356, + "min": 1.6677139776810554, + "max": 2.7105559608728185, + "q25": 1.9777806594401668, + "q50": 2.21764125242753, + "q75": 2.5039235973072005, + "std": 0.28303943219067185, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_8": { + "name": "feature_2_8", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 21, + "avg": 0.21082238100376696, + "min": -0.021521741825759763, + "max": 0.5758245193625116, + "q25": 0.09772889589784267, + "q50": 0.19142773671987798, + "q75": 0.2965081107847877, + "std": 0.12956086883976992, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_9": { + "name": "feature_2_9", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 15, + "avg": -7.473636258432962, + "min": -7.7060621499240565, + "max": -7.272973962251777, + "q25": -7.540311767048805, + "q50": -7.4486865221524745, + "q75": -7.409897130096452, + "std": 0.11580130671422861, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_2_10": { + "name": "feature_2_10", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 11, + "avg": -0.04675299224970586, + "min": -0.34262789316886166, + "max": 0.1282850912346699, + "q25": -0.11898731786030345, + "q50": -0.02534497036266615, + "q75": 0.04721966669048455, + "std": 0.13398483070150566, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_1": { + "name": "feature_3_1", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 21, + "avg": -0.23511552117431594, + "min": -0.45715727202993256, + "max": 0.17140128546897984, + "q25": -0.3300352837555922, + "q50": -0.22639023793816065, + "q75": -0.15961375991220164, + "std": 0.13414475414084567, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_2": { + "name": "feature_3_2", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 27, + "avg": 0.08145059913486928, + "min": -0.21468467631910326, + "max": 0.3000717669791855, + "q25": 0.038245096234426124, + "q50": 0.08884513685475545, + "q75": 0.13877452381845268, + "std": 0.11112937112930686, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_3": { + "name": "feature_3_3", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 7, + "avg": -0.20391352520774528, + "min": -0.696289340651918, + "max": 0.07389933055073145, + "q25": -0.21414547612669016, + "q50": -0.13404160537759308, + "q75": -0.13404160537759308, + "std": 0.18248602147099546, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_4": { + "name": "feature_3_4", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 9, + "avg": -0.14237080497102328, + "min": -0.287810300831832, + "max": 0.010684053390404269, + "q25": -0.15991801391544605, + "q50": -0.15991801391544605, + "q75": -0.10038447275439095, + "std": 0.07615457562111168, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_5": { + "name": "feature_3_5", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 25, + "avg": -0.07697881371402719, + "min": -0.4496618381879538, + "max": 0.2859731329653391, + "q25": -0.16689650273448975, + "q50": -0.06456103587368225, + "q75": -0.006646221384359696, + "std": 0.1703789377586864, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_6": { + "name": "feature_3_6", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": -0.3562449872317344, + "min": -0.3685292971362768, + "max": 3.6762017848461976e-16, + "q25": -0.3685292971362768, + "q50": -0.3685292971362768, + "q75": -0.3685292971362768, + "std": 0.06728393638102102, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_7": { + "name": "feature_3_7", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 13, + "avg": -0.47723873827109115, + "min": -0.5646511566087611, + "max": -0.3647858362062366, + "q25": -0.5325635138546246, + "q50": -0.5027495825792233, + "q75": -0.4431217200284206, + "std": 0.0609433896224526, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_8": { + "name": "feature_3_8", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 9, + "avg": -0.0830712134304094, + "min": -0.12906911404610488, + "max": 0.210618903884933, + "q25": -0.12906911404610488, + "q50": -0.12906911404610488, + "q75": -0.009095951740138164, + "std": 0.081767372523437, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_9": { + "name": "feature_3_9", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 17, + "avg": -0.28747432059097855, + "min": -0.3878998715737425, + "max": -0.20029877019826361, + "q25": -0.3259658095695609, + "q50": -0.2898674759956072, + "q75": -0.2537691424216535, + "std": 0.04564915362120373, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "feature_3_10": { + "name": "feature_3_10", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 20, + "avg": 0.07055580995490353, + "min": -0.06554862657759826, + "max": 0.12421283717173691, + "q25": 0.024132284324813073, + "q50": 0.10386319233993987, + "q75": 0.11719691210569562, + "std": 0.05044761541898693, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "3": { + "name": "3", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 3.409800000000001, + "min": 3.4098, + "max": 3.4098, + "q25": 3.4098, + "q50": 3.4098, + "q75": 3.4098, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "4": { + "name": "4", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -0.3273700000000001, + "min": -0.32737, + "max": -0.32737, + "q25": -0.32737, + "q50": -0.32737, + "q75": -0.32737, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "5": { + "name": "5", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.9604399999999994, + "min": 0.96044, + "max": 0.96044, + "q25": 0.96044, + "q50": 0.96044, + "q75": 0.96044, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "6": { + "name": "6", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -3.7436000000000003, + "min": -3.7436, + "max": -3.7436, + "q25": -3.7436, + "q50": -3.7436, + "q75": -3.7436, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "7": { + "name": "7", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -1.0191000000000008, + "min": -1.0191, + "max": -1.0191, + "q25": -1.0191, + "q50": -1.0191, + "q75": -1.0191, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "8": { + "name": "8", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -6.020499999999999, + "min": -6.0205, + "max": -6.0205, + "q25": -6.0205, + "q50": -6.0205, + "q75": -6.0205, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "9": { + "name": "9", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "10": { + "name": "10", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "11": { + "name": "11", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "12": { + "name": "12", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "13": { + "name": "13", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "14": { + "name": "14", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "15": { + "name": "15", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "16": { + "name": "16", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "17": { + "name": "17", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "18": { + "name": "18", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "19": { + "name": "19", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "20": { + "name": "20", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "21": { + "name": "21", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 8.380399999999998e-17, + "min": 8.3804e-17, + "max": 8.3804e-17, + "q25": 8.3804e-17, + "q50": 8.3804e-17, + "q75": 8.3804e-17, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "22": { + "name": "22", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -4.811599999999999, + "min": -4.8116, + "max": -4.8116, + "q25": -4.8116, + "q50": -4.8116, + "q75": -4.8116, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "23": { + "name": "23", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -1.4033000000000009, + "min": -1.4033, + "max": -1.4033, + "q25": -1.4033, + "q50": -1.4033, + "q75": -1.4033, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "24": { + "name": "24", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -0.13685999999999998, + "min": -0.13685999999999998, + "max": -0.13685999999999998, + "q25": -0.13685999999999998, + "q50": -0.13685999999999998, + "q75": -0.13685999999999998, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "25": { + "name": "25", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0024718999999999995, + "min": 0.0024719, + "max": 0.0024719, + "q25": 0.0024719, + "q50": 0.0024719, + "q75": 0.0024719, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "26": { + "name": "26", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "27": { + "name": "27", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 9.802700000000004e-16, + "min": 9.8027e-16, + "max": 9.8027e-16, + "q25": 9.8027e-16, + "q50": 9.8027e-16, + "q75": 9.8027e-16, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "28": { + "name": "28", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -55.64200000000003, + "min": -55.641999999999996, + "max": -55.641999999999996, + "q25": -55.641999999999996, + "q50": -55.641999999999996, + "q75": -55.641999999999996, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "29": { + "name": "29", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -16.31200000000001, + "min": -16.312, + "max": -16.312, + "q25": -16.312, + "q50": -16.312, + "q75": -16.312, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "30": { + "name": "30", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -1.2042, + "min": -1.2042, + "max": -1.2042, + "q25": -1.2042, + "q50": -1.2042, + "q75": -1.2042, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "31": { + "name": "31", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.021675, + "min": 0.021675, + "max": 0.021675, + "q25": 0.021675, + "q50": 0.021675, + "q75": 0.021675, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "32": { + "name": "32", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "33": { + "name": "33", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 3.409780000000001, + "min": 3.4097, + "max": 3.4098, + "q25": 3.4098, + "q50": 3.4098, + "q75": 3.4098, + "std": 0.00004068381021726342, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "34": { + "name": "34", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 6, + "avg": -0.3273716666666667, + "min": -0.3274, + "max": -0.32734, + "q25": -0.32739, + "q50": -0.32737, + "q75": -0.32736, + "std": 0.00001895245108948268, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "35": { + "name": "35", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 6, + "avg": 0.960428, + "min": 0.9603799999999999, + "max": 0.96045, + "q25": 0.96042, + "q50": 0.96043, + "q75": 0.96044, + "std": 0.000019190514898497155, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "36": { + "name": "36", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -3.743700000000001, + "min": -3.7437, + "max": -3.7437, + "q25": -3.7437, + "q50": -3.7437, + "q75": -3.7437, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "37": { + "name": "37", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -1.0191000000000008, + "min": -1.0191, + "max": -1.0191, + "q25": -1.0191, + "q50": -1.0191, + "q75": -1.0191, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "38": { + "name": "38", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -6.020499999999999, + "min": -6.0205, + "max": -6.0205, + "q25": -6.0205, + "q50": -6.0205, + "q75": -6.0205, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "39": { + "name": "39", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "40": { + "name": "40", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "41": { + "name": "41", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": -0.0, + "max": -0.0, + "q25": -0.0, + "q50": -0.0, + "q75": -0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "42": { + "name": "42", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "43": { + "name": "43", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "44": { + "name": "44", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "45": { + "name": "45", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 14, + "avg": 0.11649966666666664, + "min": 0.10088, + "max": 0.13227, + "q25": 0.11209000000000001, + "q50": 0.11657000000000001, + "q75": 0.12105999999999999, + "std": 0.00841944812809065, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "46": { + "name": "46", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 10, + "avg": -6.5501966666666664, + "min": -6.5663, + "max": -6.5416, + "q25": -6.5528, + "q50": -6.5506, + "q75": -6.5461, + "std": 0.0058114917862462125, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "47": { + "name": "47", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 12, + "avg": -2.815493333333334, + "min": -2.8336, + "max": -2.8023, + "q25": -2.818, + "q50": -2.8157, + "q75": -2.8089999999999997, + "std": 0.007310405117947096, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "48": { + "name": "48", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 12, + "avg": -0.8309449999999998, + "min": -0.84335, + "max": -0.8220000000000001, + "q25": -0.83572, + "q50": -0.83115, + "q75": -0.82657, + "std": 0.005530404206715397, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "49": { + "name": "49", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 13, + "avg": 0.07035533333333334, + "min": 0.062527, + "max": 0.082352, + "q25": 0.067102, + "q50": 0.07015199999999999, + "q75": 0.073202, + "std": 0.004801363551536481, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "50": { + "name": "50", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 20, + "avg": -0.19586799999999996, + "min": -0.20893, + "max": -0.18148, + "q25": -0.19977999999999999, + "q50": -0.19826, + "q75": -0.18911, + "std": 0.006909548315992475, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "51": { + "name": "51", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.11881999999999995, + "min": 0.11882000000000001, + "max": 0.11882000000000001, + "q25": 0.11882000000000001, + "q50": 0.11882000000000001, + "q75": 0.11882000000000001, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "52": { + "name": "52", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -6.548300000000003, + "min": -6.5483, + "max": -6.5483, + "q25": -6.5483, + "q50": -6.5483, + "q75": -6.5483, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "53": { + "name": "53", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -2.8157000000000014, + "min": -2.8157, + "max": -2.8157, + "q25": -2.8157, + "q50": -2.8157, + "q75": -2.8157, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "54": { + "name": "54", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 5, + "avg": -0.8294699999999999, + "min": -0.83267, + "max": -0.82657, + "q25": -0.83267, + "q50": -0.8281, + "q75": -0.8281, + "std": 0.0023114706469527574, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "55": { + "name": "55", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.070152, + "min": 0.07015199999999999, + "max": 0.07015199999999999, + "q25": 0.07015199999999999, + "q50": 0.07015199999999999, + "q75": 0.07015199999999999, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "56": { + "name": "56", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 5, + "avg": -0.1961233333333334, + "min": -0.19826, + "max": -0.19216, + "q25": -0.19826, + "q50": -0.19826, + "q75": -0.19368, + "std": 0.002457224862113459, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "57": { + "name": "57", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 3, + "avg": 0.7699063333333331, + "min": 0.7699, + "max": 0.7699199999999999, + "q25": 0.7699, + "q50": 0.76991, + "q75": 0.76991, + "std": 5.560534167661252e-6, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "58": { + "name": "58", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 5, + "avg": 0.41001499999999996, + "min": 0.41, + "max": 0.41003999999999996, + "q25": 0.41001000000000004, + "q50": 0.410015, + "q75": 0.41002, + "std": 0.000011371470653687081, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "59": { + "name": "59", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 28, + "avg": 0.08279083333333333, + "min": 0.082758, + "max": 0.082817, + "q25": 0.082774, + "q50": 0.08279249999999999, + "q75": 0.082804, + "std": 0.000016772480196858457, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "60": { + "name": "60", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": -1.4093633333333337, + "min": -1.4094, + "max": -1.4093, + "q25": -1.4094, + "q50": -1.4094, + "q75": -1.4093, + "std": 0.000049013251785353614, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "61": { + "name": "61", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 10, + "avg": 0.7859533333333333, + "min": 0.7859, + "max": 0.7859999999999999, + "q25": 0.78595, + "q50": 0.78596, + "q75": 0.78597, + "std": 0.000026565901573916655, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "62": { + "name": "62", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 9, + "avg": -0.36821200000000004, + "min": -0.36827, + "max": -0.36818, + "q25": -0.36823, + "q50": -0.36821, + "q75": -0.36819, + "std": 0.000023252734359046097, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "63": { + "name": "63", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "64": { + "name": "64", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "65": { + "name": "65", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "66": { + "name": "66", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "67": { + "name": "67", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "68": { + "name": "68", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "69": { + "name": "69", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 29, + "avg": -22.271400000000003, + "min": -23.2, + "max": -21.288, + "q25": -22.673000000000002, + "q50": -22.372, + "q75": -21.839000000000002, + "std": 0.5428036159765707, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "70": { + "name": "70", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 35, + "avg": -11.274933333333333, + "min": -11.845999999999998, + "max": -10.527999999999999, + "q25": -11.447000000000001, + "q50": -11.270499999999998, + "q75": -11.225999999999999, + "std": 0.2594811711105828, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "71": { + "name": "71", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 32, + "avg": -18.592833333333335, + "min": -18.939, + "max": -18.345, + "q25": -18.680999999999997, + "q50": -18.604, + "q75": -18.46, + "std": 0.14494566956772725, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "72": { + "name": "72", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 30, + "avg": -3.5490866666666667, + "min": -3.6931, + "max": -3.3167, + "q25": -3.6199, + "q50": -3.56555, + "q75": -3.4866, + "std": 0.10078614003417581, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "73": { + "name": "73", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 32, + "avg": 5.835456666666667, + "min": 5.7443, + "max": 5.9639, + "q25": 5.7874, + "q50": 5.8376, + "q75": 5.8786, + "std": 0.06015949309290594, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "74": { + "name": "74", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 27, + "avg": -1.9739266666666664, + "min": -2.1362, + "max": -1.845, + "q25": -2.019, + "q50": -1.97865, + "q75": -1.9192, + "std": 0.07078052008136494, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "75": { + "name": "75", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.7698999999999999, + "min": 0.7699, + "max": 0.7699, + "q25": 0.7699, + "q50": 0.7699, + "q75": 0.7699, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "76": { + "name": "76", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.41004000000000024, + "min": 0.41003999999999996, + "max": 0.41003999999999996, + "q25": 0.41003999999999996, + "q50": 0.41003999999999996, + "q75": 0.41003999999999996, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "77": { + "name": "77", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.08278199999999995, + "min": 0.08278200000000001, + "max": 0.08278200000000001, + "q25": 0.08278200000000001, + "q50": 0.08278200000000001, + "q75": 0.08278200000000001, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "78": { + "name": "78", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -1.4094000000000002, + "min": -1.4094, + "max": -1.4094, + "q25": -1.4094, + "q50": -1.4094, + "q75": -1.4094, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "79": { + "name": "79", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.7860000000000001, + "min": 0.7859999999999999, + "max": 0.7859999999999999, + "q25": 0.7859999999999999, + "q50": 0.7859999999999999, + "q75": 0.7859999999999999, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "80": { + "name": "80", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": -0.3681300000000001, + "min": -0.36813, + "max": -0.36813, + "q25": -0.36813, + "q50": -0.36813, + "q75": -0.36813, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "81": { + "name": "81", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "82": { + "name": "82", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "83": { + "name": "83", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "84": { + "name": "84", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "85": { + "name": "85", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "86": { + "name": "86", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 1, + "avg": 0.0, + "min": 0.0, + "max": 0.0, + "q25": 0.0, + "q50": 0.0, + "q75": 0.0, + "std": 0.0, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "98": { + "name": "98", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 48.04499999999999, + "min": 48.00899999999999, + "max": 48.068999999999996, + "q25": 48.00899999999999, + "q50": 48.068999999999996, + "q75": 48.068999999999996, + "std": 0.02989637274734736, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "99": { + "name": "99", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 48.019, + "min": 48.00899999999999, + "max": 48.068999999999996, + "q25": 48.00899999999999, + "q50": 48.00899999999999, + "q75": 48.00899999999999, + "std": 0.022742941307369282, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "100": { + "name": "100", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 7, + "avg": 0.9214410000000002, + "min": 0.82357, + "max": 1.0742, + "q25": 0.89518, + "q50": 0.93099, + "q75": 0.93099, + "std": 0.054774079028754794, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "101": { + "name": "101", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 4, + "avg": 47.832666666666675, + "min": 47.803000000000004, + "max": 47.864, + "q25": 47.803000000000004, + "q50": 47.833999999999996, + "q75": 47.864, + "std": 0.024358434541922255, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "102": { + "name": "102", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 3, + "avg": 47.89466666666665, + "min": 47.879, + "max": 47.91, + "q25": 47.879, + "q50": 47.895, + "q75": 47.91, + "std": 0.012874281589150457, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "103": { + "name": "103", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 3, + "avg": 47.81966666666665, + "min": 47.788000000000004, + "max": 47.833999999999996, + "q25": 47.788000000000004, + "q50": 47.833999999999996, + "q75": 47.833999999999996, + "std": 0.021283526628521798, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "104": { + "name": "104", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 3, + "avg": 47.829166666666666, + "min": 47.818000000000005, + "max": 47.849, + "q25": 47.818000000000005, + "q50": 47.833999999999996, + "q75": 47.833999999999996, + "std": 0.008477488784531828, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "105": { + "name": "105", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 47.96033333333333, + "min": 47.955, + "max": 47.971000000000004, + "q25": 47.955, + "q50": 47.955, + "q75": 47.971000000000004, + "std": 0.0076714128237685185, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + }, + "106": { + "name": "106", + "role": "numerical", + "statistics": { + "count": 30, + "approx_unique": 2, + "avg": 47.96033333333333, + "min": 47.955, + "max": 47.971000000000004, + "q25": 47.955, + "q50": 47.955, + "q75": 47.971000000000004, + "std": 0.007671412823767137, + "null_percentage": 0.0, + "column_type": "DOUBLE", + "type": "numerical" + } + } + } + } + } +} \ No newline at end of file diff --git a/tests/integration/data/robot/robot.py b/tests/integration/data/robot/robot.py new file mode 100644 index 0000000..15bd378 --- /dev/null +++ b/tests/integration/data/robot/robot.py @@ -0,0 +1,106 @@ +from __future__ import annotations + +import logging +from pathlib import Path +from typing import cast + +import getml +from getml.data import Container, DataFrame, TimeSeries +from getml.data.columns import StringColumnView +from getml.feature_learning import Relboost +from getml.feature_learning.loss_functions import SquareLoss +from getml.pipeline import Pipeline +from getml.predictors import ( + XGBoostRegressor, +) +from pydantic.dataclasses import dataclass +from typing_extensions import override + +from tests.integration.data.datasets import DataSetName +from tests.integration.data.getmlproject import ( + GetMLProject, + GetMLProjectBundle, + GetMLProjectFactory, + getml_project_bundle, +) + +logger: logging.Logger = logging.getLogger(__name__) + + +@dataclass +class RobotProject(GetMLProject): + pass + + +class RobotProjectFactory(GetMLProjectFactory): + @override + def create( + self, + project_name: str, + session_cache_dir: Path, + ) -> RobotProject: + dataset_name: DataSetName = DataSetName.ROBOT + with getml_project_bundle( + GetMLProjectBundle( + project_name, + session_cache_dir, + dataset_name, + ), + ) as project_bundle: + name: str = project_bundle.name + dataframe: DataFrame = self._get_dataframe(dataset_name) + split: StringColumnView = self._get_split(dataframe) + timeseries: TimeSeries = self._get_timeseries( + dataframe, + split, + ) + container: Container = timeseries.container + pipeline: Pipeline = self._ensure_fitted_pipeline( + lambda: self._create_pipeline(timeseries), + container, + ) + container.save() + return RobotProject(name, pipeline, container) + + def _get_dataframe(self, dataset_name: DataSetName) -> DataFrame: + container = self._load_getml_container(dataset_name) + return cast("DataFrame", container.full.population) + + def _get_split(self, dataframe: DataFrame) -> StringColumnView: + num_entries: int = len(dataframe) + test_start = int(num_entries * 0.6) + validation_start = int(num_entries * 0.8) + return getml.data.split.time( + dataframe, + "rowid", + test=test_start, + validation=validation_start, + ) + + def _get_timeseries( + self, + dataframe: DataFrame, + split: StringColumnView, + ) -> TimeSeries: + return getml.data.TimeSeries( + population=dataframe, + split=split, + time_stamps="rowid", + lagged_targets=False, + memory=30, + ) + + def _create_pipeline(self, timeseries: TimeSeries) -> Pipeline: + relboost: Relboost = Relboost( + loss_function=SquareLoss, + num_features=10, + ) + + xgboost_regressor: XGBoostRegressor = XGBoostRegressor() + + logger.info("Robot: Creating pipeline...") + return Pipeline( + data_model=timeseries.data_model, + feature_learners=[relboost], + predictors=[xgboost_regressor], + ) diff --git a/tests/integration/helpers.py b/tests/integration/helpers.py new file mode 100644 index 0000000..9aedfc4 --- /dev/null +++ b/tests/integration/helpers.py @@ -0,0 +1,32 @@ +import json +from pathlib import Path + +from pydantic import TypeAdapter + +from getml_io.metadata.container_information import ContainerInformation +from getml_io.metadata.pipeline_information import PipelineInformation + +ContainerInformationAdapter = TypeAdapter(ContainerInformation) +PipelineInformationAdapter = TypeAdapter(PipelineInformation) + + +def load_container_information( + container_information_json_path: Path, +) -> ContainerInformation: + assert container_information_json_path.exists() + assert container_information_json_path.is_file() + + container_information_json = json.loads(container_information_json_path.read_text()) + container_information_json["path"] = Path("dummy.json") + return ContainerInformationAdapter.validate_python(container_information_json) + + +def load_pipeline_information( + pipeline_information_json_path: Path, +) -> PipelineInformation: + assert pipeline_information_json_path.exists() + assert pipeline_information_json_path.is_file() + + pipeline_information_json = json.loads(pipeline_information_json_path.read_text()) + pipeline_information_json["path"] = Path("dummy.json") + return PipelineInformationAdapter.validate_python(pipeline_information_json) diff --git a/tests/integration/test_serialize_cora.py b/tests/integration/test_serialize_cora.py index b3a824d..39cb89b 100644 --- a/tests/integration/test_serialize_cora.py +++ b/tests/integration/test_serialize_cora.py @@ -10,7 +10,7 @@ assert_container_parquets, assert_pipeline_parquets, ) -from tests.integration.conftest import CoraProject +from tests.integration.data.cora.cora import CoraProject runner = CliRunner() diff --git a/tests/integration/test_serialize_loans.py b/tests/integration/test_serialize_loans.py index f9e84f0..c5a379d 100644 --- a/tests/integration/test_serialize_loans.py +++ b/tests/integration/test_serialize_loans.py @@ -1,4 +1,3 @@ -import json from pathlib import Path import pytest @@ -7,10 +6,16 @@ from getml_io.cli import app from getml_io.utils.convert import assume_is_str from tests.integration.assertions import ( + assert_container_information, assert_container_parquets, + assert_pipeline_information, assert_pipeline_parquets, ) -from tests.integration.conftest import LoansProject +from tests.integration.data.loans.loans import LoansProject +from tests.integration.helpers import ( + load_container_information, + load_pipeline_information, +) runner = CliRunner() @@ -19,6 +24,7 @@ def test_serialize_loans( loans_project: LoansProject, tmp_path: Path, + data_path: Path, ) -> None: # Given root_storage_directory = tmp_path @@ -37,6 +43,7 @@ def test_serialize_loans( "--root-storage-directory", str(root_storage_directory), ], + # catch_exceptions=False, # Use in case of PDB powered debugging # noqa: ERA001 ) # Then @@ -49,13 +56,13 @@ def test_serialize_loans( target_storage_directory = subdirectories[0] # Then - Container - expected_container_json = _expected_container_json( - assume_is_str(loans_project.container.id), + expected_container_information = load_container_information( + data_path / "loans" / "expected.container.json", + ) + container_information = load_container_information( + target_storage_directory / "container.json", ) - container_json = target_storage_directory / "container.json" - assert container_json.exists() - assert container_json.is_file() - assert json.loads(container_json.read_text()) == expected_container_json + assert_container_information(container_information, expected_container_information) assert_container_parquets( container_directory=target_storage_directory / "container", @@ -71,12 +78,13 @@ def test_serialize_loans( ) # Then - Pipeline - expected_pipeline_json = _expected_pipeline_json(loans_project.pipeline.id) - - pipeline_json = target_storage_directory / "pipeline.json" - assert pipeline_json.exists() - assert pipeline_json.is_file() - assert json.loads(pipeline_json.read_text()) == expected_pipeline_json + expected_pipeline_information = load_pipeline_information( + data_path / "loans" / "expected.pipeline.json", + ) + pipeline_information = load_pipeline_information( + target_storage_directory / "pipeline.json", + ) + assert_pipeline_information(pipeline_information, expected_pipeline_information) assert_pipeline_parquets( pipeline_directory=target_storage_directory / "pipeline", @@ -89,65 +97,3 @@ def test_serialize_loans( "test.parquet", ], ) - - -def _expected_container_json( - container_id: str, -) -> dict[str, str | dict[str, dict[str, str]] | bool | None]: - return { - "id": container_id, - "population": None, - "peripheral": { - "meta": { - "name": "meta", - "path": "container/peripheral/meta.parquet", - }, - "order": { - "name": "order", - "path": "container/peripheral/order.parquet", - }, - "trans": { - "name": "trans", - "path": "container/peripheral/trans.parquet", - }, - }, - "subsets": { - "train": { - "name": "train", - "path": "container/subsets/train.parquet", - }, - "test": { - "name": "test", - "path": "container/subsets/test.parquet", - }, - }, - "deep_copy": False, - } - - -def _expected_pipeline_json( - pipeline_id: str, -) -> dict[str, str | dict[str, dict[str, str]]]: - return { - "id": pipeline_id, - "predictions": { - "train": { - "name": "train", - "path": "pipeline/predictions/train.parquet", - }, - "test": { - "name": "test", - "path": "pipeline/predictions/test.parquet", - }, - }, - "feature_sets": { - "train": { - "name": "features.train", - "path": "pipeline/feature_sets/features.train.parquet", - }, - "test": { - "name": "features.test", - "path": "pipeline/feature_sets/features.test.parquet", - }, - }, - } diff --git a/tests/integration/test_serialize_numerical.py b/tests/integration/test_serialize_numerical.py index bc8aecd..10b82d0 100644 --- a/tests/integration/test_serialize_numerical.py +++ b/tests/integration/test_serialize_numerical.py @@ -1,4 +1,3 @@ -import json from pathlib import Path import pytest @@ -7,10 +6,16 @@ from getml_io.cli import app from getml_io.utils.convert import assume_is_str from tests.integration.assertions import ( + assert_container_information, assert_container_parquets, + assert_pipeline_information, assert_pipeline_parquets, ) -from tests.integration.conftest import NumericalProject +from tests.integration.data.numerical.numerical import NumericalProject +from tests.integration.helpers import ( + load_container_information, + load_pipeline_information, +) runner = CliRunner() @@ -19,6 +24,7 @@ def test_serialize_numerical( numerical_project: NumericalProject, tmp_path: Path, + data_path: Path, ) -> None: # Given root_storage_directory = tmp_path @@ -37,6 +43,7 @@ def test_serialize_numerical( "--root-storage-directory", str(root_storage_directory), ], + # catch_exceptions=False, # Use in case of PDB powered debugging # noqa: ERA001 ) # Then @@ -49,13 +56,13 @@ def test_serialize_numerical( target_storage_directory = subdirectories[0] # Then - Container - expected_container_json = _expected_container_json( - assume_is_str(numerical_project.container.id), + expected_container_information = load_container_information( + data_path / "numerical" / "expected.container.json", + ) + container_information = load_container_information( + target_storage_directory / "container.json", ) - container_json = target_storage_directory / "container.json" - assert container_json.exists() - assert container_json.is_file() - assert json.loads(container_json.read_text()) == expected_container_json + assert_container_information(container_information, expected_container_information) assert_container_parquets( container_directory=target_storage_directory / "container", @@ -69,11 +76,13 @@ def test_serialize_numerical( ) # Then - Pipeline - expected_pipeline_json = _expected_pipeline_json(numerical_project.pipeline.id) - pipeline_json = target_storage_directory / "pipeline.json" - assert pipeline_json.exists() - assert pipeline_json.is_file() - assert json.loads(pipeline_json.read_text()) == expected_pipeline_json + expected_pipeline_information = load_pipeline_information( + data_path / "numerical" / "expected.pipeline.json", + ) + pipeline_information = load_pipeline_information( + target_storage_directory / "pipeline.json", + ) + assert_pipeline_information(pipeline_information, expected_pipeline_information) assert_pipeline_parquets( pipeline_directory=target_storage_directory / "pipeline", @@ -86,57 +95,3 @@ def test_serialize_numerical( "test.parquet", ], ) - - -def _expected_container_json( - container_id: str, -) -> dict[str, str | dict[str, dict[str, str]] | bool | None]: - return { - "id": container_id, - "population": None, - "peripheral": { - "perph": { - "name": "perph", - "path": "container/peripheral/perph.parquet", - }, - }, - "subsets": { - "train": { - "name": "train", - "path": "container/subsets/train.parquet", - }, - "test": { - "name": "test", - "path": "container/subsets/test.parquet", - }, - }, - "deep_copy": False, - } - - -def _expected_pipeline_json( - pipeline_id: str, -) -> dict[str, str | dict[str, dict[str, str]]]: - return { - "id": pipeline_id, - "predictions": { - "train": { - "name": "train", - "path": "pipeline/predictions/train.parquet", - }, - "test": { - "name": "test", - "path": "pipeline/predictions/test.parquet", - }, - }, - "feature_sets": { - "train": { - "name": "features.train", - "path": "pipeline/feature_sets/features.train.parquet", - }, - "test": { - "name": "features.test", - "path": "pipeline/feature_sets/features.test.parquet", - }, - }, - } diff --git a/tests/integration/test_serialize_robot.py b/tests/integration/test_serialize_robot.py index 47a2572..39acd28 100644 --- a/tests/integration/test_serialize_robot.py +++ b/tests/integration/test_serialize_robot.py @@ -1,4 +1,3 @@ -import json from pathlib import Path import pytest @@ -7,10 +6,16 @@ from getml_io.cli import app from getml_io.utils.convert import assume_is_str from tests.integration.assertions import ( + assert_container_information, assert_container_parquets, + assert_pipeline_information, assert_pipeline_parquets, ) -from tests.integration.conftest import RobotProject +from tests.integration.data.robot.robot import RobotProject +from tests.integration.helpers import ( + load_container_information, + load_pipeline_information, +) runner = CliRunner() @@ -19,6 +24,7 @@ def test_serialize_robot( robot_project: RobotProject, tmp_path: Path, + data_path: Path, ) -> None: # Given root_storage_directory = tmp_path @@ -37,6 +43,7 @@ def test_serialize_robot( "--root-storage-directory", str(root_storage_directory), ], + # catch_exceptions=False, # Use in case of PDB powered debugging # noqa: ERA001 ) # Then @@ -49,13 +56,13 @@ def test_serialize_robot( target_storage_directory = subdirectories[0] # Then - Container - expected_container_json = _expected_container_json( - assume_is_str(robot_project.container.id), + expected_container_information = load_container_information( + data_path / "robot" / "expected.container.json", + ) + container_information = load_container_information( + target_storage_directory / "container.json", ) - container_json = target_storage_directory / "container.json" - assert container_json.exists() - assert container_json.is_file() - assert json.loads(container_json.read_text()) == expected_container_json + assert_container_information(container_information, expected_container_information) assert_container_parquets( container_directory=target_storage_directory / "container", @@ -70,11 +77,13 @@ def test_serialize_robot( ) # Then - Pipeline - expected_pipeline_json = _expected_pipeline_json(robot_project.pipeline.id) - pipeline_json = target_storage_directory / "pipeline.json" - assert pipeline_json.exists() - assert pipeline_json.is_file() - assert json.loads(pipeline_json.read_text()) == expected_pipeline_json + expected_pipeline_information = load_pipeline_information( + data_path / "robot" / "expected.pipeline.json", + ) + pipeline_information = load_pipeline_information( + target_storage_directory / "pipeline.json", + ) + assert_pipeline_information(pipeline_information, expected_pipeline_information) assert_pipeline_parquets( pipeline_directory=target_storage_directory / "pipeline", @@ -89,69 +98,3 @@ def test_serialize_robot( "validation.parquet", ], ) - - -def _expected_container_json( - container_id: str, -) -> dict[str, str | dict[str, dict[str, str]] | bool | None]: - return { - "id": container_id, - "population": None, - "peripheral": { - "full": { - "name": "full", - "path": "container/peripheral/full.parquet", - }, - }, - "subsets": { - "train": { - "name": "full", - "path": "container/subsets/train.full.parquet", - }, - "validation": { - "name": "full", - "path": "container/subsets/validation.full.parquet", - }, - "test": { - "name": "full", - "path": "container/subsets/test.full.parquet", - }, - }, - "deep_copy": False, - } - - -def _expected_pipeline_json( - pipeline_id: str, -) -> dict[str, str | dict[str, dict[str, str]]]: - return { - "id": pipeline_id, - "predictions": { - "train": { - "name": "train", - "path": "pipeline/predictions/train.parquet", - }, - "validation": { - "name": "validation", - "path": "pipeline/predictions/validation.parquet", - }, - "test": { - "name": "test", - "path": "pipeline/predictions/test.parquet", - }, - }, - "feature_sets": { - "train": { - "name": "features.train", - "path": "pipeline/feature_sets/features.train.parquet", - }, - "validation": { - "name": "features.validation", - "path": "pipeline/feature_sets/features.validation.parquet", - }, - "test": { - "name": "features.test", - "path": "pipeline/feature_sets/features.test.parquet", - }, - }, - } diff --git a/tests/unit/conftest.py b/tests/unit/conftest.py index 79fbd05..ec0d544 100644 --- a/tests/unit/conftest.py +++ b/tests/unit/conftest.py @@ -1,11 +1,16 @@ +import copy import dataclasses +import re from collections.abc import Mapping from pathlib import Path from typing import Protocol +import getml.data.roles as getml_roles import numpy as np +import pandas as pd import pytest import pytest_mock +from duckdb import DuckDBPyConnection from getml.data import Container, DataFrame, Subset, View from getml.pipeline import Pipeline from numpy.typing import NDArray @@ -13,11 +18,17 @@ from getml_io.getml.project import Project from getml_io.getml.project_information import ProjectInformation from getml_io.metadata.container_information import ContainerInformation -from getml_io.metadata.dataframe_information import DataFrameInformation +from getml_io.metadata.dataframe_information import ( + ColumnProfile, + ColumnStatisticsNumerical, + DataFrameInformation, + Role, +) from getml_io.metadata.feature_sets import FeatureSets from getml_io.metadata.pipeline_information import PipelineInformation from getml_io.metadata.prediction_results import PredictionResults from getml_io.metadata.table_information import TableInformation +from getml_io.utils.convert import assume_is_str @pytest.fixture @@ -38,17 +49,17 @@ class ContainerSpec(Protocol): @pytest.fixture -def mock_population(mocker: pytest_mock.MockerFixture) -> DataFrame: - dataframe = mocker.Mock() +def mock_population(mock_dataframe: DataFrame) -> DataFrame: + dataframe = copy.deepcopy(mock_dataframe) dataframe.name = "mock_population_name" return dataframe @pytest.fixture -def mock_peripheral(mocker: pytest_mock.MockerFixture) -> dict[str, DataFrame]: - dataframe = mocker.Mock() +def mock_peripheral(mock_dataframe: DataFrame) -> dict[str, DataFrame]: + dataframe = copy.deepcopy(mock_dataframe) dataframe.name = "mock_peripheral_name" - return {dataframe.name: dataframe} + return {assume_is_str(dataframe.name): dataframe} @pytest.fixture @@ -117,33 +128,60 @@ def container_information_empty(tmp_path: Path) -> ContainerInformation: ) +@pytest.fixture +def profile_default() -> ColumnProfile: + return ColumnProfile( + name="default", + role=Role.NUMERICAL, + statistics=ColumnStatisticsNumerical( + count=1, + approx_unique=1, + avg=1, + min=1, + max=1, + q25=1, + q50=1, + q75=1, + std=1, + null_percentage=1, + column_type="DOUBLE", + ), + ) + + @pytest.fixture def dataframe_information_population( tmp_path: Path, + profile_default: ColumnProfile, ) -> DataFrameInformation: return DataFrameInformation( name="population", path=tmp_path / "population.parquet", + profile={"default": profile_default}, ) @pytest.fixture def dataframe_information_peripheral( tmp_path: Path, + profile_default: ColumnProfile, ) -> DataFrameInformation: return DataFrameInformation( name="peripheral", path=tmp_path / "peripheral.parquet", + profile={"default": profile_default}, ) @pytest.fixture def dataframe_information_subset( tmp_path: Path, + profile_default: ColumnProfile, ) -> DataFrameInformation: return DataFrameInformation( name="subset", path=tmp_path / "subset.parquet", + profile={"default": profile_default}, ) @@ -178,14 +216,28 @@ def mock_dataframe( ) -> DataFrame: dataframe = mocker.Mock(DataFrame) dataframe.name = "mock_dataframe_name" + dataframe.columns = [ + "Categorical0", + "Categorical1", + "Categorical2", + "Categorical3", + "Numerical0", + "Numerical1", + "Numerical2", + "Numerical3", + ] + dataframe.roles = mocker.MagicMock() + dataframe.roles.column = ( + lambda name: getml_roles.categorical + if name.startswith("Categorical") + else getml_roles.numerical + ) return dataframe @pytest.fixture -def mock_dataframe_train( - mocker: pytest_mock.MockerFixture, -) -> DataFrame: - dataframe = mocker.Mock(DataFrame) +def mock_dataframe_train(mock_dataframe: DataFrame) -> DataFrame: + dataframe = copy.deepcopy(mock_dataframe) dataframe.name = "mock_dataframe_train" return dataframe @@ -193,56 +245,62 @@ def mock_dataframe_train( @pytest.fixture def dataframe_information_train( tmp_path: Path, + profile_default: ColumnProfile, ) -> DataFrameInformation: return DataFrameInformation( name="dataframe_train", path=tmp_path / "dataframe_train.parquet", + profile={"default": profile_default}, ) @pytest.fixture def dataframe_information_test( tmp_path: Path, + profile_default: ColumnProfile, ) -> DataFrameInformation: return DataFrameInformation( name="dataframe_test", path=tmp_path / "dataframe_test.parquet", + profile={"default": profile_default}, ) @pytest.fixture def dataframe_information_validation( tmp_path: Path, + profile_default: ColumnProfile, ) -> DataFrameInformation: return DataFrameInformation( name="dataframe_validation", path=tmp_path / "dataframe_validation.parquet", + profile={"default": profile_default}, ) @pytest.fixture -def mock_dataframe_test( - mocker: pytest_mock.MockerFixture, -) -> DataFrame: - dataframe = mocker.Mock(DataFrame) +def mock_dataframe_test(mock_dataframe: DataFrame) -> DataFrame: + dataframe = copy.deepcopy(mock_dataframe) dataframe.name = "mock_dataframe_test" return dataframe @pytest.fixture -def mock_dataframe_validation( - mocker: pytest_mock.MockerFixture, -) -> DataFrame: - dataframe = mocker.Mock(DataFrame) +def mock_dataframe_validation(mock_dataframe: DataFrame) -> DataFrame: + dataframe = copy.deepcopy(mock_dataframe) dataframe.name = "mock_dataframe_validation" return dataframe @pytest.fixture -def dataframe_information(tmp_path: Path) -> DataFrameInformation: +def dataframe_information( + tmp_path: Path, + profile_default: ColumnProfile, +) -> DataFrameInformation: return DataFrameInformation( name="dataframe_name", path=tmp_path / "dataframe_name.parquet", + profile={"default": profile_default}, ) @@ -275,8 +333,9 @@ def mock_pipeline( pipeline.predict = lambda _: ndarray def pipeline_transform(_: DataFrame | View | Subset, *, df_name: str) -> DataFrame: - mock_dataframe.name = df_name - return mock_dataframe + dataframe = copy.deepcopy(mock_dataframe) + dataframe.name = df_name + return dataframe pipeline.transform = pipeline_transform return pipeline @@ -325,20 +384,24 @@ def table_information_validation( @pytest.fixture def dataframe_information_features_test( tmp_path: Path, + profile_default: ColumnProfile, ) -> DataFrameInformation: return DataFrameInformation( name="features.test", path=tmp_path / "features.test.parquet", + profile={"default": profile_default}, ) @pytest.fixture def dataframe_information_features_validation( tmp_path: Path, + profile_default: ColumnProfile, ) -> DataFrameInformation: return DataFrameInformation( name="features.validation", path=tmp_path / "features.validation.parquet", + profile={"default": profile_default}, ) @@ -390,3 +453,82 @@ def pipeline_information( ), path=tmp_path, ) + + +def generate_raw_summary_statistics_pd(dataframe: DataFrame | View) -> pd.DataFrame: + data = { + "column_name": dict(enumerate(dataframe.columns)), + "column_type": { + index: "VARCHAR" + if ( + dataframe.roles.column(name) + in {getml_roles.categorical, getml_roles.text} + ) + else "DOUBLE" + for index, name in enumerate(dataframe.columns) + }, + "min": { + index: "" + if dataframe.roles.column(name) == getml_roles.categorical + else 0.0 + for index, name in enumerate(dataframe.columns) + }, + "max": { + index: "" + if dataframe.roles.column(name) == getml_roles.categorical + else 0.0 + for index, name in enumerate(dataframe.columns) + }, + "approx_unique": dict.fromkeys(range(len(dataframe.columns)), 0), + "avg": dict.fromkeys(range(len(dataframe.columns)), float("nan")), + "std": dict.fromkeys(range(len(dataframe.columns)), float("nan")), + "q25": dict.fromkeys(range(len(dataframe.columns)), float("nan")), + "q50": dict.fromkeys(range(len(dataframe.columns)), float("nan")), + "q75": dict.fromkeys(range(len(dataframe.columns)), float("nan")), + "count": dict.fromkeys(range(len(dataframe.columns)), 0), + "null_percentage": dict.fromkeys( + range(len(dataframe.columns)), + float("nan"), + ), + } + return pd.DataFrame(data) + + +class MockDuckDBExecuteFactory(Protocol): + def __call__(self, dataframes_by_path: dict[Path, DataFrame | View]) -> None: ... + + +REGEX_READ_PARQUET = re.compile(r"read_parquet\(\"(?P[^\"]+)\"\)") + + +@pytest.fixture +def mock_duckdb_execute_factory( + mocker: pytest_mock.MockerFixture, + tmp_path: Path, +) -> MockDuckDBExecuteFactory: + def mock_duckdb_execute(dataframes_by_path: dict[Path, DataFrame | View]) -> None: + connection_context_manager = mocker.MagicMock(DuckDBPyConnection) + connection = mocker.MagicMock(DuckDBPyConnection) + connection_context_manager.__enter__.return_value = connection + _ = mocker.patch( + "getml_io.serialize.dataframe_or_view.duckdb.connect", + return_value=connection_context_manager, + ) + + def mocked_execute(_query: str, parameters: list[str]) -> DuckDBPyConnection: + assert len(parameters) == 1 + current_parquet_path = Path(parameters[0]) + mock_execution = mocker.MagicMock(DuckDBPyConnection) + + def mocked_df() -> pd.DataFrame: + current_dataframe = dataframes_by_path[ + current_parquet_path.relative_to(tmp_path) + ] + return generate_raw_summary_statistics_pd(current_dataframe) + + mock_execution.df.side_effect = mocked_df + return mock_execution + + connection.execute.side_effect = mocked_execute + + return mock_duckdb_execute diff --git a/tests/unit/metadata/test_container_information.py b/tests/unit/metadata/test_container_information.py index 1e18c10..a4d78ad 100644 --- a/tests/unit/metadata/test_container_information.py +++ b/tests/unit/metadata/test_container_information.py @@ -4,6 +4,7 @@ from pydantic import TypeAdapter from getml_io.metadata.container_information import ContainerInformation +from getml_io.metadata.dataframe_information import Role @pytest.mark.unit @@ -34,30 +35,55 @@ def test_serialize_model( ) # Then + expected_profile = { + "default": { + "name": "default", + "role": Role.NUMERICAL, + "statistics": { + "count": 1, + "approx_unique": 1, + "avg": 1.0, + "min": 1.0, + "max": 1.0, + "q25": 1.0, + "q50": 1.0, + "q75": 1.0, + "std": 1.0, + "null_percentage": 1.0, + "column_type": "DOUBLE", + "type": "numerical", + }, + }, + } assert serialized_model == { "id": "container_id", "population": { "name": "population", "path": Path("population.parquet"), + "profile": expected_profile, }, "peripheral": { "peripheral": { "name": "peripheral", "path": Path("peripheral.parquet"), + "profile": expected_profile, }, }, "subsets": { "train": { "name": "dataframe_train", "path": Path("dataframe_train.parquet"), + "profile": expected_profile, }, "test": { "name": "dataframe_test", "path": Path("dataframe_test.parquet"), + "profile": expected_profile, }, "validation": { "name": "dataframe_validation", "path": Path("dataframe_validation.parquet"), + "profile": expected_profile, }, }, "deep_copy": True, diff --git a/tests/unit/metadata/test_pipeline_information.py b/tests/unit/metadata/test_pipeline_information.py index fb9dc4a..15a1f84 100644 --- a/tests/unit/metadata/test_pipeline_information.py +++ b/tests/unit/metadata/test_pipeline_information.py @@ -3,6 +3,7 @@ import pytest from pydantic import TypeAdapter +from getml_io.metadata.dataframe_information import Role from getml_io.metadata.pipeline_information import PipelineInformation @@ -33,6 +34,26 @@ def test_serialize_model( ) # Then + expected_profile = { + "default": { + "name": "default", + "role": Role.NUMERICAL, + "statistics": { + "count": 1, + "approx_unique": 1, + "avg": 1.0, + "min": 1.0, + "max": 1.0, + "q25": 1.0, + "q50": 1.0, + "q75": 1.0, + "std": 1.0, + "null_percentage": 1.0, + "column_type": "DOUBLE", + "type": "numerical", + }, + }, + } assert serialized_model == { "id": "pipeline_id", "predictions": { @@ -49,10 +70,12 @@ def test_serialize_model( "test": { "name": "features.test", "path": Path("pipeline/feature_sets/features.test.parquet"), + "profile": expected_profile, }, "validation": { "name": "features.validation", "path": Path("pipeline/feature_sets/features.validation.parquet"), + "profile": expected_profile, }, }, } diff --git a/tests/unit/serialize/test_container.py b/tests/unit/serialize/test_container.py index bd3b950..6685170 100644 --- a/tests/unit/serialize/test_container.py +++ b/tests/unit/serialize/test_container.py @@ -5,11 +5,45 @@ from getml.data import Container from getml_io.serialize.container import serialize_container +from getml_io.utils.convert import ( + assume_is_dict_str_to_dataframe_or_view, + assume_is_optional_dataframe_or_view, +) +from tests.unit.conftest import MockDuckDBExecuteFactory @pytest.mark.unit -def test_serialize_container(mock_container: Container, tmp_path: Path) -> None: +def test_serialize_container( + mock_container: Container, + tmp_path: Path, + mock_duckdb_execute_factory: MockDuckDBExecuteFactory, +) -> None: # Given + population = assume_is_optional_dataframe_or_view(mock_container.population) + mock_duckdb_execute_factory( + { + **( + {Path(f"container/population/{population.name}.parquet"): population} + if population is not None + else {} + ), + **{ + Path( + f"container/peripheral/{peripheral.name}.parquet", + ): peripheral + for peripheral in assume_is_dict_str_to_dataframe_or_view( + mock_container.peripheral, + ).values() + }, + **{ + Path(f"container/subsets/{subset_name}.{subset.name}.parquet"): subset + for subset_name, subset in assume_is_dict_str_to_dataframe_or_view( + mock_container.subsets, + ).items() + }, + }, + ) + mock_container.path = tmp_path # When @@ -61,32 +95,103 @@ def test_serialize_container(mock_container: Container, tmp_path: Path) -> None: assert not container_information.deep_copy + expected_statistics_categorical = { + "approx_unique": 0, + "column_type": "VARCHAR", + "count": 0, + "max": "", + "min": "", + "null_percentage": None, + "type": "categorical", + } + expected_statistics_numerical = { + "approx_unique": 0, + "avg": None, + "column_type": "DOUBLE", + "count": 0, + "max": 0.0, + "min": 0.0, + "null_percentage": None, + "q25": None, + "q50": None, + "q75": None, + "std": None, + "type": "numerical", + } + expected_profile = { + "Categorical0": { + "name": "Categorical0", + "role": "categorical", + "statistics": expected_statistics_categorical, + }, + "Categorical1": { + "name": "Categorical1", + "role": "categorical", + "statistics": expected_statistics_categorical, + }, + "Categorical2": { + "name": "Categorical2", + "role": "categorical", + "statistics": expected_statistics_categorical, + }, + "Categorical3": { + "name": "Categorical3", + "role": "categorical", + "statistics": expected_statistics_categorical, + }, + "Numerical0": { + "name": "Numerical0", + "role": "numerical", + "statistics": expected_statistics_numerical, + }, + "Numerical1": { + "name": "Numerical1", + "role": "numerical", + "statistics": expected_statistics_numerical, + }, + "Numerical2": { + "name": "Numerical2", + "role": "numerical", + "statistics": expected_statistics_numerical, + }, + "Numerical3": { + "name": "Numerical3", + "role": "numerical", + "statistics": expected_statistics_numerical, + }, + } + expected_container_json_content = { "id": "mock_container_id", "population": { "name": "mock_population_name", "path": "container/population/mock_population_name.parquet", + "profile": expected_profile, }, "peripheral": { "mock_peripheral_name": { "name": "mock_peripheral_name", "path": ("container/peripheral/mock_peripheral_name.parquet"), + "profile": expected_profile, }, }, "subsets": { "test": { "name": "mock_dataframe_test", "path": "container/subsets/test.mock_dataframe_test.parquet", + "profile": expected_profile, }, "train": { "name": "mock_dataframe_train", "path": "container/subsets/train.mock_dataframe_train.parquet", + "profile": expected_profile, }, "validation": { "name": "mock_dataframe_validation", "path": ( "container/subsets/validation.mock_dataframe_validation.parquet" ), + "profile": expected_profile, }, }, "deep_copy": False, diff --git a/tests/unit/serialize/test_dataframe_or_view.py b/tests/unit/serialize/test_dataframe_or_view.py index 1dbe7da..86ba23d 100644 --- a/tests/unit/serialize/test_dataframe_or_view.py +++ b/tests/unit/serialize/test_dataframe_or_view.py @@ -1,12 +1,26 @@ +from collections.abc import Mapping from pathlib import Path import pytest import pytest_mock from getml.data import DataFrame +from pydantic import TypeAdapter +from getml_io.metadata.dataframe_information import ( + ColumnProfile, + ColumnStatisticsCategorical, + ColumnStatisticsNumerical, + Role, +) from getml_io.serialize.dataframe_or_view import serialize_dataframe_or_view -from getml_io.serialize.exception import DataFrameParquetStorageError +from getml_io.serialize.exception import ( + DataFrameParquetStorageError, + UnsupportedColumnStatisticsError, +) from getml_io.utils.exception import StorageDirectoryCreationError +from tests.unit.conftest import MockDuckDBExecuteFactory + +ColumnProfileAdapter = TypeAdapter(ColumnProfile) @pytest.mark.unit @@ -14,8 +28,15 @@ def test_serialize_dataframe_or_view( tmp_path: Path, mocker: pytest_mock.MockerFixture, mock_dataframe: DataFrame, + mock_duckdb_execute_factory: MockDuckDBExecuteFactory, ) -> None: # Given + mock_duckdb_execute_factory( + { + Path(f"dataframes/{mock_dataframe.name}.parquet"): mock_dataframe, + }, + ) + target_storage_directory = tmp_path / "dataframes" mock_dataframe.to_parquet = mocker.Mock() @@ -31,6 +52,83 @@ def test_serialize_dataframe_or_view( assert serialized_info.path == expected_parquet_path mock_dataframe.to_parquet.assert_called_once_with(str(expected_parquet_path)) + nan = float("nan") + expected_statistics_categorical = ColumnStatisticsCategorical( + count=0, + approx_unique=0, + min="", + max="", + null_percentage=nan, + column_type="VARCHAR", + type="categorical", + ) + expected_statistics_numerical = ColumnStatisticsNumerical( + count=0, + approx_unique=0, + avg=nan, + min=0.0, + max=0.0, + q25=nan, + q50=nan, + q75=nan, + std=nan, + null_percentage=nan, + column_type="DOUBLE", + type="numerical", + ) + expected_profile = { + "Categorical0": ColumnProfile( + name="Categorical0", + role=Role.CATEGORICAL, + statistics=expected_statistics_categorical, + ), + "Categorical1": ColumnProfile( + name="Categorical1", + role=Role.CATEGORICAL, + statistics=expected_statistics_categorical, + ), + "Categorical2": ColumnProfile( + name="Categorical2", + role=Role.CATEGORICAL, + statistics=expected_statistics_categorical, + ), + "Categorical3": ColumnProfile( + name="Categorical3", + role=Role.CATEGORICAL, + statistics=expected_statistics_categorical, + ), + "Numerical0": ColumnProfile( + name="Numerical0", + role=Role.NUMERICAL, + statistics=expected_statistics_numerical, + ), + "Numerical1": ColumnProfile( + name="Numerical1", + role=Role.NUMERICAL, + statistics=expected_statistics_numerical, + ), + "Numerical2": ColumnProfile( + name="Numerical2", + role=Role.NUMERICAL, + statistics=expected_statistics_numerical, + ), + "Numerical3": ColumnProfile( + name="Numerical3", + role=Role.NUMERICAL, + statistics=expected_statistics_numerical, + ), + } + assert profile_to_json(serialized_info.profile) == profile_to_json(expected_profile) + + +def profile_to_json( + profile: Mapping[str, ColumnProfile], +) -> dict[str, bytes]: + return { + column_name: ColumnProfileAdapter.dump_json(column_profile) + for column_name, column_profile in profile.items() + } + @pytest.mark.unit def test_serialize_dataframe_or_view_directory_creation_error( @@ -66,3 +164,33 @@ def test_serialize_dataframe_or_view_storage_error( match=r"Failed to store DataFrame as parquet 'mock_dataframe_name' at path", ): _ = serialize_dataframe_or_view(mock_dataframe, target_storage_directory) + + +@pytest.mark.unit +def test_serialize_dataframe_or_view_statistics_role_error( + tmp_path: Path, + mocker: pytest_mock.MockerFixture, + mock_dataframe: DataFrame, + mock_duckdb_execute_factory: MockDuckDBExecuteFactory, +) -> None: + # Given + mock_duckdb_execute_factory( + { + Path(f"dataframes/{mock_dataframe.name}.parquet"): mock_dataframe, + }, + ) + + target_storage_directory = tmp_path / "dataframes" + mock_dataframe.to_parquet = mocker.Mock() + _ = mocker.patch.object(mock_dataframe.roles, "column", return_value=Role.TEXT) + _ = mocker.patch.object(mock_dataframe, "columns", ["Text0"]) + + # When / Then + with pytest.raises( + UnsupportedColumnStatisticsError, + match=( + rf"Column 'Text0' in dataframe 'mock_dataframe_name' " + rf"has an unsupported role: {Role.TEXT!r} and type: VARCHAR" + ), + ): + _ = serialize_dataframe_or_view(mock_dataframe, target_storage_directory) diff --git a/tests/unit/serialize/test_pipeline.py b/tests/unit/serialize/test_pipeline.py index fb4b3b6..87cc522 100644 --- a/tests/unit/serialize/test_pipeline.py +++ b/tests/unit/serialize/test_pipeline.py @@ -1,7 +1,7 @@ from pathlib import Path import pytest -from getml.data import Container +from getml.data import Container, DataFrame from getml.pipeline import Pipeline from getml_io.metadata.feature_sets import FeatureSets @@ -11,6 +11,7 @@ serialize_pipeline, serialize_predictions, ) +from tests.unit.conftest import MockDuckDBExecuteFactory @pytest.mark.unit @@ -18,7 +19,18 @@ def test_serialize_pipeline( tmp_path: Path, mock_pipeline: Pipeline, mock_container: Container, + mock_duckdb_execute_factory: MockDuckDBExecuteFactory, + mock_dataframe: DataFrame, ) -> None: + # Given + mock_duckdb_execute_factory( + { + Path("pipeline/feature_sets/features.train.parquet"): mock_dataframe, + Path("pipeline/feature_sets/features.test.parquet"): mock_dataframe, + Path("pipeline/feature_sets/features.validation.parquet"): mock_dataframe, + }, + ) + # When pipeline_information_json_path, pipeline_information = serialize_pipeline( mock_pipeline, @@ -84,7 +96,18 @@ def test_serialize_feature_sets( tmp_path: Path, mock_pipeline: Pipeline, mock_container: Container, + mock_duckdb_execute_factory: MockDuckDBExecuteFactory, + mock_dataframe: DataFrame, ) -> None: + # Given + mock_duckdb_execute_factory( + { + Path("feature_sets/features.train.parquet"): mock_dataframe, + Path("feature_sets/features.test.parquet"): mock_dataframe, + Path("feature_sets/features.validation.parquet"): mock_dataframe, + }, + ) + # When feature_sets = serialize_feature_sets( mock_pipeline,