1from cpdbench.control.TestbenchController import TestbenchController, TestrunType + 2from cpdbench.utils import Logger, BenchConfig + 3 + 4 + 5class CPDBench: + 6 """Main class for accessing the CPDBench functions""" + 7 + 8 def __init__(self): + 9 self._datasets = [] +10 self._algorithms = [] +11 self._metrics = [] +12 self._logger = None +13 +14 def start(self, config_file: str = None) -> None: +15 """Start the execution of the CDPBench environment +16 :param config_file: Path to the CDPBench configuration file; defaults to 'config.yml' +17 """ +18 BenchConfig.load_config(config_file) +19 self._logger = Logger.get_application_logger() +20 self._logger.debug('CPDBench object created') +21 self._logger.info("Starting CPDBench") +22 self._logger.info(f"Got {len(self._datasets)} datasets, {len(self._algorithms)} algorithms and " +23 f"{len(self._metrics)} metrics") +24 bench = TestbenchController() +25 bench.execute_testrun(TestrunType.NORMAL_RUN, self._datasets, self._algorithms, self._metrics) +26 +27 def validate(self, config_file: str = 'config.yml') -> None: +28 """Validate the given functions for a full bench run. Throws an exception if the validation fails. +29 :param config_file: Path to the CDPBench configuration file; defaults to 'config.yml' +30 """ +31 BenchConfig.load_config(config_file) +32 self._logger = Logger.get_application_logger() +33 self._logger.debug('CPDBench object created') +34 self._logger.info("Starting CPDBench validator") +35 self._logger.info(f"Got {len(self._datasets)} datasets, {len(self._algorithms)} algorithms and " +36 f"{len(self._metrics)} metrics") +37 bench = TestbenchController() +38 bench.execute_testrun(TestrunType.VALIDATION_RUN, self._datasets, self._algorithms, self._metrics) +39 +40 def dataset(self, function): +41 """Decorator for dataset functions which create CPDDataset objects""" +42 +43 # self._logger.debug(f'Got a dataset function: {Utils.get_name_of_function(function)}') +44 self._datasets.append(function) +45 return function +46 +47 def algorithm(self, function): +48 """Decorator for algorithm functions which execute changepoint algorithms""" +49 +50 # self._logger.debug(f'Got an algorithm function: {Utils.get_name_of_function(function)}') +51 self._algorithms.append(function) +52 return function +53 +54 def metric(self, function): +55 """Decorator for metric functions which evaluate changepoint results""" +56 +57 # self._logger.debug(f'Got a metric function: {Utils.get_name_of_function(function)}') +58 self._metrics.append(function) +59 return function +
6class CPDBench: + 7 """Main class for accessing the CPDBench functions""" + 8 + 9 def __init__(self): +10 self._datasets = [] +11 self._algorithms = [] +12 self._metrics = [] +13 self._logger = None +14 +15 def start(self, config_file: str = None) -> None: +16 """Start the execution of the CDPBench environment +17 :param config_file: Path to the CDPBench configuration file; defaults to 'config.yml' +18 """ +19 BenchConfig.load_config(config_file) +20 self._logger = Logger.get_application_logger() +21 self._logger.debug('CPDBench object created') +22 self._logger.info("Starting CPDBench") +23 self._logger.info(f"Got {len(self._datasets)} datasets, {len(self._algorithms)} algorithms and " +24 f"{len(self._metrics)} metrics") +25 bench = TestbenchController() +26 bench.execute_testrun(TestrunType.NORMAL_RUN, self._datasets, self._algorithms, self._metrics) +27 +28 def validate(self, config_file: str = 'config.yml') -> None: +29 """Validate the given functions for a full bench run. Throws an exception if the validation fails. +30 :param config_file: Path to the CDPBench configuration file; defaults to 'config.yml' +31 """ +32 BenchConfig.load_config(config_file) +33 self._logger = Logger.get_application_logger() +34 self._logger.debug('CPDBench object created') +35 self._logger.info("Starting CPDBench validator") +36 self._logger.info(f"Got {len(self._datasets)} datasets, {len(self._algorithms)} algorithms and " +37 f"{len(self._metrics)} metrics") +38 bench = TestbenchController() +39 bench.execute_testrun(TestrunType.VALIDATION_RUN, self._datasets, self._algorithms, self._metrics) +40 +41 def dataset(self, function): +42 """Decorator for dataset functions which create CPDDataset objects""" +43 +44 # self._logger.debug(f'Got a dataset function: {Utils.get_name_of_function(function)}') +45 self._datasets.append(function) +46 return function +47 +48 def algorithm(self, function): +49 """Decorator for algorithm functions which execute changepoint algorithms""" +50 +51 # self._logger.debug(f'Got an algorithm function: {Utils.get_name_of_function(function)}') +52 self._algorithms.append(function) +53 return function +54 +55 def metric(self, function): +56 """Decorator for metric functions which evaluate changepoint results""" +57 +58 # self._logger.debug(f'Got a metric function: {Utils.get_name_of_function(function)}') +59 self._metrics.append(function) +60 return function +
Main class for accessing the CPDBench functions
+15 def start(self, config_file: str = None) -> None: +16 """Start the execution of the CDPBench environment +17 :param config_file: Path to the CDPBench configuration file; defaults to 'config.yml' +18 """ +19 BenchConfig.load_config(config_file) +20 self._logger = Logger.get_application_logger() +21 self._logger.debug('CPDBench object created') +22 self._logger.info("Starting CPDBench") +23 self._logger.info(f"Got {len(self._datasets)} datasets, {len(self._algorithms)} algorithms and " +24 f"{len(self._metrics)} metrics") +25 bench = TestbenchController() +26 bench.execute_testrun(TestrunType.NORMAL_RUN, self._datasets, self._algorithms, self._metrics) +
Start the execution of the CDPBench environment
+ +28 def validate(self, config_file: str = 'config.yml') -> None: +29 """Validate the given functions for a full bench run. Throws an exception if the validation fails. +30 :param config_file: Path to the CDPBench configuration file; defaults to 'config.yml' +31 """ +32 BenchConfig.load_config(config_file) +33 self._logger = Logger.get_application_logger() +34 self._logger.debug('CPDBench object created') +35 self._logger.info("Starting CPDBench validator") +36 self._logger.info(f"Got {len(self._datasets)} datasets, {len(self._algorithms)} algorithms and " +37 f"{len(self._metrics)} metrics") +38 bench = TestbenchController() +39 bench.execute_testrun(TestrunType.VALIDATION_RUN, self._datasets, self._algorithms, self._metrics) +
Validate the given functions for a full bench run. Throws an exception if the validation fails.
+ +41 def dataset(self, function): +42 """Decorator for dataset functions which create CPDDataset objects""" +43 +44 # self._logger.debug(f'Got a dataset function: {Utils.get_name_of_function(function)}') +45 self._datasets.append(function) +46 return function +
Decorator for dataset functions which create CPDDataset objects
+48 def algorithm(self, function): +49 """Decorator for algorithm functions which execute changepoint algorithms""" +50 +51 # self._logger.debug(f'Got an algorithm function: {Utils.get_name_of_function(function)}') +52 self._algorithms.append(function) +53 return function +
Decorator for algorithm functions which execute changepoint algorithms
+55 def metric(self, function): +56 """Decorator for metric functions which evaluate changepoint results""" +57 +58 # self._logger.debug(f'Got a metric function: {Utils.get_name_of_function(function)}') +59 self._metrics.append(function) +60 return function +
Decorator for metric functions which evaluate changepoint results
+This package contains all classes responsible for running the main program logic, +especially the testbench runs.
+1from enum import Enum + 2 + 3from cpdbench.exception.ResultSetInconsistentException import ResultSetInconsistentException + 4import traceback + 5 + 6from cpdbench.task.Task import Task + 7 + 8 + 9class ErrorType(str, Enum): + 10 """Enum for all error types which can occur during the CPDBench execution""" + 11 DATASET_ERROR = "DATASET_ERROR" + 12 ALGORITHM_ERROR = "ALGORITHM_ERROR" + 13 METRIC_ERROR = "METRIC_ERROR" + 14 + 15 + 16class CPDDatasetResult: + 17 """Container for all results of one single dataset including algorithm and metric results""" + 18 + 19 def __init__(self, dataset: Task, algorithms: list[Task], metrics: list[Task]): + 20 """Constructs a dataset result with the basic attributes + 21 :param dataset: task which created the dataset + 22 :param algorithms: list of all algorithm tasks which were used with this dataset + 23 :param metrics: list of all metric tasks which were used with this dataset + 24 """ + 25 + 26 self._dataset = dataset.get_task_name() + 27 self._algorithms = [a.get_task_name() for a in algorithms] + 28 self._metrics = [m.get_task_name() for m in metrics] + 29 + 30 self._indexes = {} + 31 self._scores = {} + 32 self._metric_scores = {} + 33 + 34 self._errors = [] + 35 self._parameters = ({self._dataset: dataset.get_param_dict()} + 36 | {task.get_task_name(): task.get_param_dict() for task in algorithms} + 37 | {task.get_task_name(): task.get_param_dict() for task in metrics}) + 38 + 39 self._dataset_runtime = -1 + 40 self._algorithm_runtimes = {} + 41 for a in self._algorithms: + 42 self._metric_scores[a] = {} + 43 + 44 def add_dataset_runtime(self, runtime: float) -> None: + 45 """Adds the runtime of the dataset task to the result object. + 46 Once a runtime was added, the value is immutable. + 47 :param runtime: the runtime of the task in seconds + 48 """ + 49 if self._dataset_runtime == -1: + 50 self._dataset_runtime = runtime + 51 + 52 def add_algorithm_result(self, indexes: list[int], scores: list[float], algorithm: str, runtime: float) -> None: + 53 """Adds an algorithm result with indexes and confidence scores to the result container. + 54 :param indexes: list of calculated changepoint indexes + 55 :param scores: list of calculated confidence scores respective to the indexes list + 56 :param algorithm: name of the calculated algorithm + 57 :param runtime: runtime of the algorithm execution in seconds + 58 """ + 59 + 60 if algorithm not in self._algorithms: + 61 raise ResultSetInconsistentException(f"Algorithm {algorithm} does not exist") + 62 self._indexes[algorithm] = indexes + 63 self._scores[algorithm] = scores + 64 self._algorithm_runtimes[algorithm] = {} + 65 self._algorithm_runtimes[algorithm]["runtime"] = runtime + 66 + 67 def add_metric_score(self, metric_score: float, algorithm: str, metric: str, runtime: float) -> None: + 68 """Adds a metric result of an algorithm/dataset to the result container. + 69 :param metric_score: calculated metric score as float + 70 :param algorithm: name of the calculated algorithm + 71 :param metric: name of the used metric + 72 :param runtime: runtime of the metric execution in seconds + 73 """ + 74 + 75 if (algorithm not in self._algorithms + 76 or metric not in self._metrics): + 77 raise ResultSetInconsistentException() + 78 if self._indexes.get(algorithm) is None: + 79 raise ResultSetInconsistentException() + 80 self._metric_scores[algorithm][metric] = metric_score + 81 self._algorithm_runtimes[algorithm][metric] = runtime + 82 + 83 def add_error(self, exception: Exception, error_type: ErrorType, algorithm: str = None, metric: str = None) -> None: + 84 """Adds a thrown error to the result container. + 85 :param exception: the thrown exception object + 86 :param error_type: the error type of the thrown exception + 87 :param algorithm: name of the algorithm where the exception occurred if applicable + 88 :param metric: name of the metric where the exception occurred if applicable + 89 """ + 90 + 91 self._errors.append((type(exception).__name__, ''.join(traceback.format_exception(None, exception, + 92 exception.__traceback__)), + 93 error_type, algorithm, metric)) + 94 + 95 def get_result_as_dict(self) -> dict: + 96 """Returns the result container formatted as dictionary. + 97 :returns: the complete results with indexes, scores and metric scores of one dataset as dict + 98 """ + 99 +100 return { +101 self._dataset: { +102 "indexes": self._indexes, +103 "scores": self._scores, +104 "metric_scores": self._metric_scores +105 } +106 } +107 +108 def get_errors_as_list(self) -> list: +109 """Returns the list of errors occurred around the dataset. +110 :returns: all errors of the dataset as python list +111 """ +112 +113 return [ +114 { +115 "dataset": self._dataset, +116 "error_type": error[2], +117 "algorithm": error[3], +118 "metric": error[4], +119 "exception_type": error[0], +120 "trace_back": error[1] +121 } +122 for error in self._errors +123 ] +124 +125 def get_parameters(self) -> dict: +126 """Returns the parameters of all included tasks as dict. +127 :returns: the parameters as python dict +128 """ +129 return self._parameters +130 +131 def get_runtimes(self) -> dict: +132 """Returns the runtimes of all included tasks as dict. +133 :returns: the runtimes as python dict +134 """ +135 if self._dataset_runtime == -1: +136 result_dict = {self._dataset: self._algorithm_runtimes} +137 else: +138 result_dict = { +139 self._dataset: self._algorithm_runtimes | { +140 "runtime": self._dataset_runtime, +141 } +142 } +143 return result_dict +
10class ErrorType(str, Enum): +11 """Enum for all error types which can occur during the CPDBench execution""" +12 DATASET_ERROR = "DATASET_ERROR" +13 ALGORITHM_ERROR = "ALGORITHM_ERROR" +14 METRIC_ERROR = "METRIC_ERROR" +
Enum for all error types which can occur during the CPDBench execution
+17class CPDDatasetResult: + 18 """Container for all results of one single dataset including algorithm and metric results""" + 19 + 20 def __init__(self, dataset: Task, algorithms: list[Task], metrics: list[Task]): + 21 """Constructs a dataset result with the basic attributes + 22 :param dataset: task which created the dataset + 23 :param algorithms: list of all algorithm tasks which were used with this dataset + 24 :param metrics: list of all metric tasks which were used with this dataset + 25 """ + 26 + 27 self._dataset = dataset.get_task_name() + 28 self._algorithms = [a.get_task_name() for a in algorithms] + 29 self._metrics = [m.get_task_name() for m in metrics] + 30 + 31 self._indexes = {} + 32 self._scores = {} + 33 self._metric_scores = {} + 34 + 35 self._errors = [] + 36 self._parameters = ({self._dataset: dataset.get_param_dict()} + 37 | {task.get_task_name(): task.get_param_dict() for task in algorithms} + 38 | {task.get_task_name(): task.get_param_dict() for task in metrics}) + 39 + 40 self._dataset_runtime = -1 + 41 self._algorithm_runtimes = {} + 42 for a in self._algorithms: + 43 self._metric_scores[a] = {} + 44 + 45 def add_dataset_runtime(self, runtime: float) -> None: + 46 """Adds the runtime of the dataset task to the result object. + 47 Once a runtime was added, the value is immutable. + 48 :param runtime: the runtime of the task in seconds + 49 """ + 50 if self._dataset_runtime == -1: + 51 self._dataset_runtime = runtime + 52 + 53 def add_algorithm_result(self, indexes: list[int], scores: list[float], algorithm: str, runtime: float) -> None: + 54 """Adds an algorithm result with indexes and confidence scores to the result container. + 55 :param indexes: list of calculated changepoint indexes + 56 :param scores: list of calculated confidence scores respective to the indexes list + 57 :param algorithm: name of the calculated algorithm + 58 :param runtime: runtime of the algorithm execution in seconds + 59 """ + 60 + 61 if algorithm not in self._algorithms: + 62 raise ResultSetInconsistentException(f"Algorithm {algorithm} does not exist") + 63 self._indexes[algorithm] = indexes + 64 self._scores[algorithm] = scores + 65 self._algorithm_runtimes[algorithm] = {} + 66 self._algorithm_runtimes[algorithm]["runtime"] = runtime + 67 + 68 def add_metric_score(self, metric_score: float, algorithm: str, metric: str, runtime: float) -> None: + 69 """Adds a metric result of an algorithm/dataset to the result container. + 70 :param metric_score: calculated metric score as float + 71 :param algorithm: name of the calculated algorithm + 72 :param metric: name of the used metric + 73 :param runtime: runtime of the metric execution in seconds + 74 """ + 75 + 76 if (algorithm not in self._algorithms + 77 or metric not in self._metrics): + 78 raise ResultSetInconsistentException() + 79 if self._indexes.get(algorithm) is None: + 80 raise ResultSetInconsistentException() + 81 self._metric_scores[algorithm][metric] = metric_score + 82 self._algorithm_runtimes[algorithm][metric] = runtime + 83 + 84 def add_error(self, exception: Exception, error_type: ErrorType, algorithm: str = None, metric: str = None) -> None: + 85 """Adds a thrown error to the result container. + 86 :param exception: the thrown exception object + 87 :param error_type: the error type of the thrown exception + 88 :param algorithm: name of the algorithm where the exception occurred if applicable + 89 :param metric: name of the metric where the exception occurred if applicable + 90 """ + 91 + 92 self._errors.append((type(exception).__name__, ''.join(traceback.format_exception(None, exception, + 93 exception.__traceback__)), + 94 error_type, algorithm, metric)) + 95 + 96 def get_result_as_dict(self) -> dict: + 97 """Returns the result container formatted as dictionary. + 98 :returns: the complete results with indexes, scores and metric scores of one dataset as dict + 99 """ +100 +101 return { +102 self._dataset: { +103 "indexes": self._indexes, +104 "scores": self._scores, +105 "metric_scores": self._metric_scores +106 } +107 } +108 +109 def get_errors_as_list(self) -> list: +110 """Returns the list of errors occurred around the dataset. +111 :returns: all errors of the dataset as python list +112 """ +113 +114 return [ +115 { +116 "dataset": self._dataset, +117 "error_type": error[2], +118 "algorithm": error[3], +119 "metric": error[4], +120 "exception_type": error[0], +121 "trace_back": error[1] +122 } +123 for error in self._errors +124 ] +125 +126 def get_parameters(self) -> dict: +127 """Returns the parameters of all included tasks as dict. +128 :returns: the parameters as python dict +129 """ +130 return self._parameters +131 +132 def get_runtimes(self) -> dict: +133 """Returns the runtimes of all included tasks as dict. +134 :returns: the runtimes as python dict +135 """ +136 if self._dataset_runtime == -1: +137 result_dict = {self._dataset: self._algorithm_runtimes} +138 else: +139 result_dict = { +140 self._dataset: self._algorithm_runtimes | { +141 "runtime": self._dataset_runtime, +142 } +143 } +144 return result_dict +
Container for all results of one single dataset including algorithm and metric results
+20 def __init__(self, dataset: Task, algorithms: list[Task], metrics: list[Task]): +21 """Constructs a dataset result with the basic attributes +22 :param dataset: task which created the dataset +23 :param algorithms: list of all algorithm tasks which were used with this dataset +24 :param metrics: list of all metric tasks which were used with this dataset +25 """ +26 +27 self._dataset = dataset.get_task_name() +28 self._algorithms = [a.get_task_name() for a in algorithms] +29 self._metrics = [m.get_task_name() for m in metrics] +30 +31 self._indexes = {} +32 self._scores = {} +33 self._metric_scores = {} +34 +35 self._errors = [] +36 self._parameters = ({self._dataset: dataset.get_param_dict()} +37 | {task.get_task_name(): task.get_param_dict() for task in algorithms} +38 | {task.get_task_name(): task.get_param_dict() for task in metrics}) +39 +40 self._dataset_runtime = -1 +41 self._algorithm_runtimes = {} +42 for a in self._algorithms: +43 self._metric_scores[a] = {} +
Constructs a dataset result with the basic attributes
+ +45 def add_dataset_runtime(self, runtime: float) -> None: +46 """Adds the runtime of the dataset task to the result object. +47 Once a runtime was added, the value is immutable. +48 :param runtime: the runtime of the task in seconds +49 """ +50 if self._dataset_runtime == -1: +51 self._dataset_runtime = runtime +
Adds the runtime of the dataset task to the result object. +Once a runtime was added, the value is immutable.
+ +53 def add_algorithm_result(self, indexes: list[int], scores: list[float], algorithm: str, runtime: float) -> None: +54 """Adds an algorithm result with indexes and confidence scores to the result container. +55 :param indexes: list of calculated changepoint indexes +56 :param scores: list of calculated confidence scores respective to the indexes list +57 :param algorithm: name of the calculated algorithm +58 :param runtime: runtime of the algorithm execution in seconds +59 """ +60 +61 if algorithm not in self._algorithms: +62 raise ResultSetInconsistentException(f"Algorithm {algorithm} does not exist") +63 self._indexes[algorithm] = indexes +64 self._scores[algorithm] = scores +65 self._algorithm_runtimes[algorithm] = {} +66 self._algorithm_runtimes[algorithm]["runtime"] = runtime +
Adds an algorithm result with indexes and confidence scores to the result container.
+ +68 def add_metric_score(self, metric_score: float, algorithm: str, metric: str, runtime: float) -> None: +69 """Adds a metric result of an algorithm/dataset to the result container. +70 :param metric_score: calculated metric score as float +71 :param algorithm: name of the calculated algorithm +72 :param metric: name of the used metric +73 :param runtime: runtime of the metric execution in seconds +74 """ +75 +76 if (algorithm not in self._algorithms +77 or metric not in self._metrics): +78 raise ResultSetInconsistentException() +79 if self._indexes.get(algorithm) is None: +80 raise ResultSetInconsistentException() +81 self._metric_scores[algorithm][metric] = metric_score +82 self._algorithm_runtimes[algorithm][metric] = runtime +
Adds a metric result of an algorithm/dataset to the result container.
+ +84 def add_error(self, exception: Exception, error_type: ErrorType, algorithm: str = None, metric: str = None) -> None: +85 """Adds a thrown error to the result container. +86 :param exception: the thrown exception object +87 :param error_type: the error type of the thrown exception +88 :param algorithm: name of the algorithm where the exception occurred if applicable +89 :param metric: name of the metric where the exception occurred if applicable +90 """ +91 +92 self._errors.append((type(exception).__name__, ''.join(traceback.format_exception(None, exception, +93 exception.__traceback__)), +94 error_type, algorithm, metric)) +
Adds a thrown error to the result container.
+ +96 def get_result_as_dict(self) -> dict: + 97 """Returns the result container formatted as dictionary. + 98 :returns: the complete results with indexes, scores and metric scores of one dataset as dict + 99 """ +100 +101 return { +102 self._dataset: { +103 "indexes": self._indexes, +104 "scores": self._scores, +105 "metric_scores": self._metric_scores +106 } +107 } +
Returns the result container formatted as dictionary. +:returns: the complete results with indexes, scores and metric scores of one dataset as dict
+109 def get_errors_as_list(self) -> list: +110 """Returns the list of errors occurred around the dataset. +111 :returns: all errors of the dataset as python list +112 """ +113 +114 return [ +115 { +116 "dataset": self._dataset, +117 "error_type": error[2], +118 "algorithm": error[3], +119 "metric": error[4], +120 "exception_type": error[0], +121 "trace_back": error[1] +122 } +123 for error in self._errors +124 ] +
Returns the list of errors occurred around the dataset. +:returns: all errors of the dataset as python list
+126 def get_parameters(self) -> dict: +127 """Returns the parameters of all included tasks as dict. +128 :returns: the parameters as python dict +129 """ +130 return self._parameters +
Returns the parameters of all included tasks as dict. +:returns: the parameters as python dict
+132 def get_runtimes(self) -> dict: +133 """Returns the runtimes of all included tasks as dict. +134 :returns: the runtimes as python dict +135 """ +136 if self._dataset_runtime == -1: +137 result_dict = {self._dataset: self._algorithm_runtimes} +138 else: +139 result_dict = { +140 self._dataset: self._algorithm_runtimes | { +141 "runtime": self._dataset_runtime, +142 } +143 } +144 return result_dict +
Returns the runtimes of all included tasks as dict. +:returns: the runtimes as python dict
+1from cpdbench.control.CPDDatasetResult import CPDDatasetResult + 2import datetime + 3 + 4from cpdbench.control.CPDResult import CPDResult + 5 + 6 + 7class CPDFullResult(CPDResult): + 8 """Container for a complete run result with all datasets""" + 9 +10 def __init__(self, datasets: list[str], algorithms: list[str], metrics: list[str]): +11 """Construct a CPDFullResult object with basic metadata +12 :param datasets: list of all dataset names as strings +13 :param algorithms: list of all used changepoint algorithms as strings +14 :param metrics: list of all metrics as strings +15 """ +16 self._result = {} +17 self._created = datetime.datetime.now() +18 self._last_updated = self._created +19 self._datasets = datasets +20 self._algorithms = algorithms +21 self._metrics = metrics +22 self._errors = [] +23 self._parameters = {} +24 self._runtimes = {} +25 +26 def add_dataset_result(self, dataset_result: CPDDatasetResult) -> None: +27 """Adds a calculated dataset result to the FullResult +28 :param dataset_result: the dataset result to add +29 """ +30 self._result = self._result | dataset_result.get_result_as_dict() +31 self._errors += dataset_result.get_errors_as_list() +32 self._last_updated = datetime.datetime.now() +33 self._parameters = self._parameters | dataset_result.get_parameters() +34 self._runtimes = self._runtimes | dataset_result.get_runtimes() +35 +36 def get_result_as_dict(self) -> dict: +37 """Returns the complete result with all dataset results and metadata as python dict +38 :return: the result as python dict +39 """ +40 return { +41 "datasets": self._datasets, +42 "algorithms": self._algorithms, +43 "metrics": self._metrics, +44 "created": self._created.strftime("%m/%d/%Y, %H:%M:%S"), +45 "last_updated": self._last_updated.strftime("%m/%d/%Y, %H:%M:%S"), +46 "parameters": self._parameters, +47 "results": self._result, +48 "runtimes": self._runtimes, +49 "errors": self._errors +50 } +
8class CPDFullResult(CPDResult): + 9 """Container for a complete run result with all datasets""" +10 +11 def __init__(self, datasets: list[str], algorithms: list[str], metrics: list[str]): +12 """Construct a CPDFullResult object with basic metadata +13 :param datasets: list of all dataset names as strings +14 :param algorithms: list of all used changepoint algorithms as strings +15 :param metrics: list of all metrics as strings +16 """ +17 self._result = {} +18 self._created = datetime.datetime.now() +19 self._last_updated = self._created +20 self._datasets = datasets +21 self._algorithms = algorithms +22 self._metrics = metrics +23 self._errors = [] +24 self._parameters = {} +25 self._runtimes = {} +26 +27 def add_dataset_result(self, dataset_result: CPDDatasetResult) -> None: +28 """Adds a calculated dataset result to the FullResult +29 :param dataset_result: the dataset result to add +30 """ +31 self._result = self._result | dataset_result.get_result_as_dict() +32 self._errors += dataset_result.get_errors_as_list() +33 self._last_updated = datetime.datetime.now() +34 self._parameters = self._parameters | dataset_result.get_parameters() +35 self._runtimes = self._runtimes | dataset_result.get_runtimes() +36 +37 def get_result_as_dict(self) -> dict: +38 """Returns the complete result with all dataset results and metadata as python dict +39 :return: the result as python dict +40 """ +41 return { +42 "datasets": self._datasets, +43 "algorithms": self._algorithms, +44 "metrics": self._metrics, +45 "created": self._created.strftime("%m/%d/%Y, %H:%M:%S"), +46 "last_updated": self._last_updated.strftime("%m/%d/%Y, %H:%M:%S"), +47 "parameters": self._parameters, +48 "results": self._result, +49 "runtimes": self._runtimes, +50 "errors": self._errors +51 } +
Container for a complete run result with all datasets
+11 def __init__(self, datasets: list[str], algorithms: list[str], metrics: list[str]): +12 """Construct a CPDFullResult object with basic metadata +13 :param datasets: list of all dataset names as strings +14 :param algorithms: list of all used changepoint algorithms as strings +15 :param metrics: list of all metrics as strings +16 """ +17 self._result = {} +18 self._created = datetime.datetime.now() +19 self._last_updated = self._created +20 self._datasets = datasets +21 self._algorithms = algorithms +22 self._metrics = metrics +23 self._errors = [] +24 self._parameters = {} +25 self._runtimes = {} +
Construct a CPDFullResult object with basic metadata
+ +27 def add_dataset_result(self, dataset_result: CPDDatasetResult) -> None: +28 """Adds a calculated dataset result to the FullResult +29 :param dataset_result: the dataset result to add +30 """ +31 self._result = self._result | dataset_result.get_result_as_dict() +32 self._errors += dataset_result.get_errors_as_list() +33 self._last_updated = datetime.datetime.now() +34 self._parameters = self._parameters | dataset_result.get_parameters() +35 self._runtimes = self._runtimes | dataset_result.get_runtimes() +
Adds a calculated dataset result to the FullResult
+ +37 def get_result_as_dict(self) -> dict: +38 """Returns the complete result with all dataset results and metadata as python dict +39 :return: the result as python dict +40 """ +41 return { +42 "datasets": self._datasets, +43 "algorithms": self._algorithms, +44 "metrics": self._metrics, +45 "created": self._created.strftime("%m/%d/%Y, %H:%M:%S"), +46 "last_updated": self._last_updated.strftime("%m/%d/%Y, %H:%M:%S"), +47 "parameters": self._parameters, +48 "results": self._result, +49 "runtimes": self._runtimes, +50 "errors": self._errors +51 } +
Returns the complete result with all dataset results and metadata as python dict
+ +++the result as python dict
+
5class CPDResult(ABC): + 6 """Abstract class for result containers for bench runs""" + 7 + 8 @abstractmethod + 9 def get_result_as_dict(self) -> dict: +10 """Returns the result of the bench run as python dict""" +11 pass +
Abstract class for result containers for bench runs
+1import datetime + 2import traceback + 3 + 4from cpdbench.control.CPDResult import CPDResult + 5 + 6 + 7class CPDValidationResult(CPDResult): + 8 """Container for a validation run result.""" + 9 +10 def __init__(self, errors: list, datasets: list[str], algorithms: list[str], metrics: list[str]): +11 """Construct a validation result object +12 :param errors: list of occurred errors during validation +13 :param datasets: list of all dataset names as strings +14 :param algorithms: list of all used changepoint algorithms as strings +15 :param metrics: list of all metrics as strings +16 """ +17 self._errors = [] +18 for error in errors: +19 self._errors.append(''.join(traceback.format_exception(None, error, error.__traceback__))) +20 self._created = datetime.datetime.now() +21 self._last_updated = self._created +22 self._datasets = datasets +23 self._algorithms = algorithms +24 self._metrics = metrics +25 +26 def get_result_as_dict(self) -> dict: +27 """Return the complete result with all dataset results and metadata as python dict +28 :return: the result as python dict +29 """ +30 return { +31 "datasets": self._datasets, +32 "algorithms": self._algorithms, +33 "metrics": self._metrics, +34 "created": self._created.strftime("%m/%d/%Y, %H:%M:%S"), +35 "last_updated": self._last_updated.strftime("%m/%d/%Y, %H:%M:%S"), +36 "errors": self._errors +37 } +
8class CPDValidationResult(CPDResult): + 9 """Container for a validation run result.""" +10 +11 def __init__(self, errors: list, datasets: list[str], algorithms: list[str], metrics: list[str]): +12 """Construct a validation result object +13 :param errors: list of occurred errors during validation +14 :param datasets: list of all dataset names as strings +15 :param algorithms: list of all used changepoint algorithms as strings +16 :param metrics: list of all metrics as strings +17 """ +18 self._errors = [] +19 for error in errors: +20 self._errors.append(''.join(traceback.format_exception(None, error, error.__traceback__))) +21 self._created = datetime.datetime.now() +22 self._last_updated = self._created +23 self._datasets = datasets +24 self._algorithms = algorithms +25 self._metrics = metrics +26 +27 def get_result_as_dict(self) -> dict: +28 """Return the complete result with all dataset results and metadata as python dict +29 :return: the result as python dict +30 """ +31 return { +32 "datasets": self._datasets, +33 "algorithms": self._algorithms, +34 "metrics": self._metrics, +35 "created": self._created.strftime("%m/%d/%Y, %H:%M:%S"), +36 "last_updated": self._last_updated.strftime("%m/%d/%Y, %H:%M:%S"), +37 "errors": self._errors +38 } +
Container for a validation run result.
+11 def __init__(self, errors: list, datasets: list[str], algorithms: list[str], metrics: list[str]): +12 """Construct a validation result object +13 :param errors: list of occurred errors during validation +14 :param datasets: list of all dataset names as strings +15 :param algorithms: list of all used changepoint algorithms as strings +16 :param metrics: list of all metrics as strings +17 """ +18 self._errors = [] +19 for error in errors: +20 self._errors.append(''.join(traceback.format_exception(None, error, error.__traceback__))) +21 self._created = datetime.datetime.now() +22 self._last_updated = self._created +23 self._datasets = datasets +24 self._algorithms = algorithms +25 self._metrics = metrics +
Construct a validation result object
+ +27 def get_result_as_dict(self) -> dict: +28 """Return the complete result with all dataset results and metadata as python dict +29 :return: the result as python dict +30 """ +31 return { +32 "datasets": self._datasets, +33 "algorithms": self._algorithms, +34 "metrics": self._metrics, +35 "created": self._created.strftime("%m/%d/%Y, %H:%M:%S"), +36 "last_updated": self._last_updated.strftime("%m/%d/%Y, %H:%M:%S"), +37 "errors": self._errors +38 } +
Return the complete result with all dataset results and metadata as python dict
+ +++the result as python dict
+
1import time + 2from concurrent.futures import ThreadPoolExecutor + 3 + 4from cpdbench.control.CPDDatasetResult import CPDDatasetResult, ErrorType + 5from cpdbench.exception.AlgorithmExecutionException import AlgorithmExecutionException + 6from cpdbench.exception.DatasetFetchException import CPDDatasetCreationException, SignalLoadingException + 7from cpdbench.exception.MetricExecutionException import MetricExecutionException + 8 + 9 + 10class DatasetExecutor: + 11 """Helper class for the TestrunController for the execution of all algorithm and metric tasks + 12 of one dataset for better structure. + 13 This executor runs on subprocesses in multiprocessing mode.""" + 14 + 15 def __init__(self, dataset_task, algorithm_tasks, metric_tasks, logger): + 16 self._result: CPDDatasetResult = None # Created later + 17 self._dataset_task = dataset_task + 18 self._algorithm_tasks = algorithm_tasks + 19 self._metric_tasks = metric_tasks + 20 self.logger = logger + 21 + 22 def execute(self): + 23 """Executes the entered algorithm and metric tasks.""" + 24 self._result = CPDDatasetResult(self._dataset_task, self._algorithm_tasks, self._metric_tasks) + 25 try: + 26 self._execute_dataset() + 27 except Exception as e: + 28 self.logger.exception(e) + 29 self._result.add_error(e, ErrorType.DATASET_ERROR) + 30 return self._result + 31 + 32 def _execute_dataset(self): + 33 try: + 34 self.logger.info(f"Start running tasks for dataset {self._dataset_task.get_task_name()}") + 35 self.logger.debug(f"Executing dataset task {self._dataset_task.get_task_name()}") + 36 runtime = time.perf_counter() + 37 dataset = self._dataset_task.execute() + 38 runtime = time.perf_counter() - runtime + 39 self._result.add_dataset_runtime(runtime) + 40 self.logger.debug(f"Finished dataset task {self._dataset_task.get_task_name()}. Took {runtime} seconds.") + 41 except Exception as e: + 42 raise CPDDatasetCreationException(self._dataset_task.get_task_name()) from e + 43 algorithms = [] + 44 with ThreadPoolExecutor(max_workers=None) as executor: + 45 self.logger.debug(f"Getting signal") + 46 try: + 47 data, ground_truth = dataset.get_signal() + 48 self.logger.debug(f"Got signal.") + 49 except Exception as e: + 50 raise SignalLoadingException(self._dataset_task.get_task_name()) from e + 51 else: + 52 self.logger.debug(f"Starting threads for executing algorithms") + 53 for algorithm in self._algorithm_tasks: + 54 algorithms.append(executor.submit(self._execute_algorithm_and_metric, data, + 55 algorithm, ground_truth)) + 56 self.logger.debug(f"Started thread for algorithm {algorithm.get_task_name()}") + 57 for i in range(0, len(algorithms)): + 58 try: + 59 algorithms[i].result() + 60 except Exception as e: + 61 self.logger.exception(e) + 62 self._result.add_error(e, ErrorType.ALGORITHM_ERROR, self._algorithm_tasks[i].get_task_name()) + 63 self.logger.debug(f"All algorithm threads are finished") + 64 self.logger.debug(f"Finished!") + 65 + 66 def _execute_algorithm_and_metric(self, dataset, algorithm, ground_truth): + 67 logger = self.logger.getChild(algorithm.get_task_name()) + 68 try: + 69 logger.debug(f"Executing algorithm task {algorithm.get_task_name()}") + 70 runtime = time.perf_counter() + 71 indexes, scores = algorithm.execute(dataset) + 72 runtime = time.perf_counter() - runtime + 73 logger.debug(f"Finished algorithm task {algorithm.get_task_name()}. Took {runtime} seconds") + 74 except Exception as e: + 75 raise AlgorithmExecutionException(algorithm.get_task_name(), + 76 self._dataset_task.get_task_name()) from e + 77 self._result.add_algorithm_result(indexes, scores, algorithm.get_task_name(), runtime) + 78 metrics = [] + 79 logger.debug(f"Starting threads for executing metrics ") + 80 with ThreadPoolExecutor(max_workers=None) as executor: + 81 for metric in self._metric_tasks: + 82 metrics.append(executor.submit(self._calculate_metric, indexes, scores, + 83 metric, ground_truth, algorithm)) + 84 logger.debug(f"Started thread for metric {metric.get_task_name()}") + 85 for i in range(0, len(metrics)): + 86 try: + 87 metrics[i].result() + 88 except Exception as e: + 89 logger.exception(e) + 90 self._result.add_error(e, ErrorType.METRIC_ERROR, algorithm.get_task_name(), + 91 self._metric_tasks[i].get_task_name()) + 92 logger.debug(f"All metric threads are finished") + 93 logger.debug(f"Finished") + 94 + 95 def _calculate_metric(self, indexes, scores, metric_task, ground_truth, algorithm): + 96 logger = self.logger.getChild(algorithm.get_task_name()).getChild(metric_task.get_task_name()) + 97 logger.debug(f"Executing metric task {metric_task.get_task_name()}") + 98 try: + 99 runtime = time.perf_counter() +100 metric_result = metric_task.execute(indexes, scores, ground_truth) +101 runtime = time.perf_counter() - runtime +102 logger.debug(f"Finished metric task {metric_task.get_task_name()}. Took {runtime} seconds") +103 except Exception as e: +104 raise MetricExecutionException(metric_task.get_task_name(), algorithm.get_task_name(), +105 self._dataset_task.get_task_name()) from e +106 self._result.add_metric_score(metric_result, algorithm.get_task_name(), metric_task.get_task_name(), runtime) +107 logger.debug("Finished") +
11class DatasetExecutor: + 12 """Helper class for the TestrunController for the execution of all algorithm and metric tasks + 13 of one dataset for better structure. + 14 This executor runs on subprocesses in multiprocessing mode.""" + 15 + 16 def __init__(self, dataset_task, algorithm_tasks, metric_tasks, logger): + 17 self._result: CPDDatasetResult = None # Created later + 18 self._dataset_task = dataset_task + 19 self._algorithm_tasks = algorithm_tasks + 20 self._metric_tasks = metric_tasks + 21 self.logger = logger + 22 + 23 def execute(self): + 24 """Executes the entered algorithm and metric tasks.""" + 25 self._result = CPDDatasetResult(self._dataset_task, self._algorithm_tasks, self._metric_tasks) + 26 try: + 27 self._execute_dataset() + 28 except Exception as e: + 29 self.logger.exception(e) + 30 self._result.add_error(e, ErrorType.DATASET_ERROR) + 31 return self._result + 32 + 33 def _execute_dataset(self): + 34 try: + 35 self.logger.info(f"Start running tasks for dataset {self._dataset_task.get_task_name()}") + 36 self.logger.debug(f"Executing dataset task {self._dataset_task.get_task_name()}") + 37 runtime = time.perf_counter() + 38 dataset = self._dataset_task.execute() + 39 runtime = time.perf_counter() - runtime + 40 self._result.add_dataset_runtime(runtime) + 41 self.logger.debug(f"Finished dataset task {self._dataset_task.get_task_name()}. Took {runtime} seconds.") + 42 except Exception as e: + 43 raise CPDDatasetCreationException(self._dataset_task.get_task_name()) from e + 44 algorithms = [] + 45 with ThreadPoolExecutor(max_workers=None) as executor: + 46 self.logger.debug(f"Getting signal") + 47 try: + 48 data, ground_truth = dataset.get_signal() + 49 self.logger.debug(f"Got signal.") + 50 except Exception as e: + 51 raise SignalLoadingException(self._dataset_task.get_task_name()) from e + 52 else: + 53 self.logger.debug(f"Starting threads for executing algorithms") + 54 for algorithm in self._algorithm_tasks: + 55 algorithms.append(executor.submit(self._execute_algorithm_and_metric, data, + 56 algorithm, ground_truth)) + 57 self.logger.debug(f"Started thread for algorithm {algorithm.get_task_name()}") + 58 for i in range(0, len(algorithms)): + 59 try: + 60 algorithms[i].result() + 61 except Exception as e: + 62 self.logger.exception(e) + 63 self._result.add_error(e, ErrorType.ALGORITHM_ERROR, self._algorithm_tasks[i].get_task_name()) + 64 self.logger.debug(f"All algorithm threads are finished") + 65 self.logger.debug(f"Finished!") + 66 + 67 def _execute_algorithm_and_metric(self, dataset, algorithm, ground_truth): + 68 logger = self.logger.getChild(algorithm.get_task_name()) + 69 try: + 70 logger.debug(f"Executing algorithm task {algorithm.get_task_name()}") + 71 runtime = time.perf_counter() + 72 indexes, scores = algorithm.execute(dataset) + 73 runtime = time.perf_counter() - runtime + 74 logger.debug(f"Finished algorithm task {algorithm.get_task_name()}. Took {runtime} seconds") + 75 except Exception as e: + 76 raise AlgorithmExecutionException(algorithm.get_task_name(), + 77 self._dataset_task.get_task_name()) from e + 78 self._result.add_algorithm_result(indexes, scores, algorithm.get_task_name(), runtime) + 79 metrics = [] + 80 logger.debug(f"Starting threads for executing metrics ") + 81 with ThreadPoolExecutor(max_workers=None) as executor: + 82 for metric in self._metric_tasks: + 83 metrics.append(executor.submit(self._calculate_metric, indexes, scores, + 84 metric, ground_truth, algorithm)) + 85 logger.debug(f"Started thread for metric {metric.get_task_name()}") + 86 for i in range(0, len(metrics)): + 87 try: + 88 metrics[i].result() + 89 except Exception as e: + 90 logger.exception(e) + 91 self._result.add_error(e, ErrorType.METRIC_ERROR, algorithm.get_task_name(), + 92 self._metric_tasks[i].get_task_name()) + 93 logger.debug(f"All metric threads are finished") + 94 logger.debug(f"Finished") + 95 + 96 def _calculate_metric(self, indexes, scores, metric_task, ground_truth, algorithm): + 97 logger = self.logger.getChild(algorithm.get_task_name()).getChild(metric_task.get_task_name()) + 98 logger.debug(f"Executing metric task {metric_task.get_task_name()}") + 99 try: +100 runtime = time.perf_counter() +101 metric_result = metric_task.execute(indexes, scores, ground_truth) +102 runtime = time.perf_counter() - runtime +103 logger.debug(f"Finished metric task {metric_task.get_task_name()}. Took {runtime} seconds") +104 except Exception as e: +105 raise MetricExecutionException(metric_task.get_task_name(), algorithm.get_task_name(), +106 self._dataset_task.get_task_name()) from e +107 self._result.add_metric_score(metric_result, algorithm.get_task_name(), metric_task.get_task_name(), runtime) +108 logger.debug("Finished") +
Helper class for the TestrunController for the execution of all algorithm and metric tasks +of one dataset for better structure. +This executor runs on subprocesses in multiprocessing mode.
+23 def execute(self): +24 """Executes the entered algorithm and metric tasks.""" +25 self._result = CPDDatasetResult(self._dataset_task, self._algorithm_tasks, self._metric_tasks) +26 try: +27 self._execute_dataset() +28 except Exception as e: +29 self.logger.exception(e) +30 self._result.add_error(e, ErrorType.DATASET_ERROR) +31 return self._result +
Executes the entered algorithm and metric tasks.
+1from abc import ABC, abstractmethod + 2 + 3from cpdbench.control.CPDResult import CPDResult + 4from cpdbench.exception.UserParameterDoesNotExistException import UserParameterDoesNotExistException + 5from cpdbench.exception.ValidationException import ValidationException + 6from cpdbench.task.Task import TaskType + 7from cpdbench.task.TaskFactory import TaskFactory + 8from cpdbench.utils import Utils + 9 +10 +11class ExecutionController(ABC): +12 """Abstract base class for testbench run configurations. +13 Each subclass has to give an execute_run() implementation with the actual run logic. +14 """ +15 +16 def __init__(self, logger): +17 self._logger = logger +18 +19 @abstractmethod +20 def execute_run(self, methods: dict) -> CPDResult: +21 """Executes the run implemented by this class. +22 :param methods: dictionary with all given input functions, grouped by function type. +23 :return: A result object which can be handed to the user +24 """ +25 pass +26 +27 def _create_tasks(self, methods: dict) -> dict: +28 """Creates task objects from the entered function handles +29 :param methods: A dictionary containing the function handles, grouped by function type +30 :return: A dictionary of task objects, which were converted from the given handles +31 """ +32 task_objects = { +33 "datasets": [], +34 "algorithms": [], +35 "metrics": [] +36 } +37 task_factory = TaskFactory() +38 for dataset_function in methods["datasets"]: +39 self._logger.debug(f"Creating and validating dataset task " +40 f"for {Utils.get_name_of_function(dataset_function)}") +41 try: +42 tasks = task_factory.create_tasks_with_parameters(dataset_function, TaskType.DATASET_FETCH) +43 except UserParameterDoesNotExistException as e: +44 self._logger.exception(e) +45 self._logger.debug(f"Creating {Utils.get_name_of_function(dataset_function)} has failed") +46 continue +47 try: +48 for task in tasks: +49 task.validate_task() +50 except ValidationException as e: +51 self._logger.exception(e) +52 else: +53 self._logger.debug(f'Validating and creating {Utils.get_name_of_function(dataset_function)} has succeeded') +54 task_objects["datasets"] += tasks +55 +56 for algorithm_function in methods["algorithms"]: +57 self._logger.debug(f"Creating and validating algorithm task " +58 f"for {Utils.get_name_of_function(algorithm_function)}") +59 try: +60 tasks = task_factory.create_tasks_with_parameters(algorithm_function, TaskType.ALGORITHM_EXECUTION) +61 except UserParameterDoesNotExistException as e: +62 self._logger.exception(e) +63 self._logger.debug(f"Creating {Utils.get_name_of_function(algorithm_function)} has failed") +64 continue +65 try: +66 for task in tasks: +67 task.validate_task() +68 except ValidationException as e: +69 self._logger.exception(e) +70 else: +71 self._logger.debug(f'Validating {Utils.get_name_of_function(algorithm_function)} has succeeded') +72 task_objects["algorithms"] += tasks +73 +74 for metric_function in methods["metrics"]: +75 self._logger.debug(f"Creating and validating metric task " +76 f"for {Utils.get_name_of_function(metric_function)}") +77 try: +78 tasks = task_factory.create_tasks_with_parameters(metric_function, TaskType.METRIC_EXECUTION) +79 except UserParameterDoesNotExistException as e: +80 self._logger.exception(e) +81 self._logger.debug(f"Creating {Utils.get_name_of_function(metric_function)} has failed") +82 continue +83 try: +84 for task in tasks: +85 task.validate_task() +86 except ValidationException as e: +87 self._logger.exception(e) +88 else: +89 self._logger.debug(f'Validating {Utils.get_name_of_function(metric_function)} has succeeded') +90 task_objects["metrics"] += tasks +91 return task_objects +
12class ExecutionController(ABC): +13 """Abstract base class for testbench run configurations. +14 Each subclass has to give an execute_run() implementation with the actual run logic. +15 """ +16 +17 def __init__(self, logger): +18 self._logger = logger +19 +20 @abstractmethod +21 def execute_run(self, methods: dict) -> CPDResult: +22 """Executes the run implemented by this class. +23 :param methods: dictionary with all given input functions, grouped by function type. +24 :return: A result object which can be handed to the user +25 """ +26 pass +27 +28 def _create_tasks(self, methods: dict) -> dict: +29 """Creates task objects from the entered function handles +30 :param methods: A dictionary containing the function handles, grouped by function type +31 :return: A dictionary of task objects, which were converted from the given handles +32 """ +33 task_objects = { +34 "datasets": [], +35 "algorithms": [], +36 "metrics": [] +37 } +38 task_factory = TaskFactory() +39 for dataset_function in methods["datasets"]: +40 self._logger.debug(f"Creating and validating dataset task " +41 f"for {Utils.get_name_of_function(dataset_function)}") +42 try: +43 tasks = task_factory.create_tasks_with_parameters(dataset_function, TaskType.DATASET_FETCH) +44 except UserParameterDoesNotExistException as e: +45 self._logger.exception(e) +46 self._logger.debug(f"Creating {Utils.get_name_of_function(dataset_function)} has failed") +47 continue +48 try: +49 for task in tasks: +50 task.validate_task() +51 except ValidationException as e: +52 self._logger.exception(e) +53 else: +54 self._logger.debug(f'Validating and creating {Utils.get_name_of_function(dataset_function)} has succeeded') +55 task_objects["datasets"] += tasks +56 +57 for algorithm_function in methods["algorithms"]: +58 self._logger.debug(f"Creating and validating algorithm task " +59 f"for {Utils.get_name_of_function(algorithm_function)}") +60 try: +61 tasks = task_factory.create_tasks_with_parameters(algorithm_function, TaskType.ALGORITHM_EXECUTION) +62 except UserParameterDoesNotExistException as e: +63 self._logger.exception(e) +64 self._logger.debug(f"Creating {Utils.get_name_of_function(algorithm_function)} has failed") +65 continue +66 try: +67 for task in tasks: +68 task.validate_task() +69 except ValidationException as e: +70 self._logger.exception(e) +71 else: +72 self._logger.debug(f'Validating {Utils.get_name_of_function(algorithm_function)} has succeeded') +73 task_objects["algorithms"] += tasks +74 +75 for metric_function in methods["metrics"]: +76 self._logger.debug(f"Creating and validating metric task " +77 f"for {Utils.get_name_of_function(metric_function)}") +78 try: +79 tasks = task_factory.create_tasks_with_parameters(metric_function, TaskType.METRIC_EXECUTION) +80 except UserParameterDoesNotExistException as e: +81 self._logger.exception(e) +82 self._logger.debug(f"Creating {Utils.get_name_of_function(metric_function)} has failed") +83 continue +84 try: +85 for task in tasks: +86 task.validate_task() +87 except ValidationException as e: +88 self._logger.exception(e) +89 else: +90 self._logger.debug(f'Validating {Utils.get_name_of_function(metric_function)} has succeeded') +91 task_objects["metrics"] += tasks +92 return task_objects +
Abstract base class for testbench run configurations. +Each subclass has to give an execute_run() implementation with the actual run logic.
+20 @abstractmethod +21 def execute_run(self, methods: dict) -> CPDResult: +22 """Executes the run implemented by this class. +23 :param methods: dictionary with all given input functions, grouped by function type. +24 :return: A result object which can be handed to the user +25 """ +26 pass +
Executes the run implemented by this class.
+ +++A result object which can be handed to the user
+
1import json + 2import logging + 3from enum import Enum + 4 + 5import numpy as np + 6 + 7from cpdbench.control.TestrunController import TestrunController + 8from cpdbench.control.ValidationRunController import ValidationRunController + 9from cpdbench.utils import BenchConfig, Logger +10 +11 +12class TestrunType(Enum): +13 """Types of predefined run configurations""" +14 NORMAL_RUN = 1, +15 VALIDATION_RUN = 2 +16 +17 +18class ExtendedEncoder(json.JSONEncoder): +19 def default(self, obj): +20 if isinstance(obj, np.integer): +21 return int(obj) +22 if isinstance(obj, np.floating): +23 return float(obj) +24 if isinstance(obj, np.ndarray): +25 return obj.tolist() +26 return super(ExtendedEncoder, self).default(obj) +27 +28 +29class TestbenchController: +30 """Main controller for starting different types of test runs. +31 This is the basic class which is executed after initialization of the framework. +32 This controller then calls an ExecutionController implementation, which contains +33 the actual logic of a run. +34 """ +35 +36 def execute_testrun(self, runtype: TestrunType, datasets: list, algorithms: list, metrics: list) -> None: +37 """Prepares and runs the required testrun +38 :param runtype: Type of testrun to run +39 :param datasets: list of dataset functions +40 :param algorithms: list of algorithm functions +41 :param metrics: list of metric functions +42 """ +43 if runtype == TestrunType.NORMAL_RUN: +44 controller = TestrunController() +45 else: +46 controller = ValidationRunController() +47 +48 function_map = { +49 "datasets": datasets, +50 "algorithms": algorithms, +51 "metrics": metrics +52 } +53 try: +54 result = controller.execute_run(function_map) +55 except Exception as e: +56 Logger.get_application_logger().critical("Unexpected error occurred during bench run. CPDBench was aborted.") +57 Logger.get_application_logger().critical(e) +58 logging.shutdown() +59 else: +60 self._output_result(result.get_result_as_dict()) +61 Logger.get_application_logger().info("CDPBench has finished. The following config has been used:") +62 Logger.get_application_logger().info(BenchConfig.get_complete_config()) +63 logging.shutdown() +64 +65 def _output_result(self, result_dict: dict) -> None: +66 """Outputs a result dict correctly on console and in a file +67 :param result_dict: the to be printed dict +68 """ +69 json_string = json.dumps(result_dict, indent=4, cls=ExtendedEncoder) +70 +71 # file output +72 with open(BenchConfig.result_file_name, 'w') as file: +73 file.write(json_string) +74 +75 # console output +76 print(json_string) +
13class TestrunType(Enum): +14 """Types of predefined run configurations""" +15 NORMAL_RUN = 1, +16 VALIDATION_RUN = 2 +
Types of predefined run configurations
+19class ExtendedEncoder(json.JSONEncoder): +20 def default(self, obj): +21 if isinstance(obj, np.integer): +22 return int(obj) +23 if isinstance(obj, np.floating): +24 return float(obj) +25 if isinstance(obj, np.ndarray): +26 return obj.tolist() +27 return super(ExtendedEncoder, self).default(obj) +
Extensible JSON http://json.org encoder for Python data structures.
+ +Supports the following objects and types by default:
+ ++-------------------+---------------+ +| Python | JSON | ++===================+===============+ +| dict | object | ++-------------------+---------------+ +| list, tuple | array | ++-------------------+---------------+ +| str | string | ++-------------------+---------------+ +| int, float | number | ++-------------------+---------------+ +| True | true | ++-------------------+---------------+ +| False | false | ++-------------------+---------------+ +| None | null | ++-------------------+---------------+
+ +To extend this to recognize other objects, subclass and implement a
+.default() method with another method that returns a serializable
+object for o if possible, otherwise it should call the superclass
+implementation (to raise TypeError).
20 def default(self, obj): +21 if isinstance(obj, np.integer): +22 return int(obj) +23 if isinstance(obj, np.floating): +24 return float(obj) +25 if isinstance(obj, np.ndarray): +26 return obj.tolist() +27 return super(ExtendedEncoder, self).default(obj) +
Implement this method in a subclass such that it returns
+a serializable object for o, or calls the base implementation
+(to raise a TypeError).
For example, to support arbitrary iterators, you could +implement default like this::
+ +def default(self, o):
+ try:
+ iterable = iter(o)
+ except TypeError:
+ pass
+ else:
+ return list(iterable)
+ # Let the base class default method raise the TypeError
+ return JSONEncoder.default(self, o)
+30class TestbenchController: +31 """Main controller for starting different types of test runs. +32 This is the basic class which is executed after initialization of the framework. +33 This controller then calls an ExecutionController implementation, which contains +34 the actual logic of a run. +35 """ +36 +37 def execute_testrun(self, runtype: TestrunType, datasets: list, algorithms: list, metrics: list) -> None: +38 """Prepares and runs the required testrun +39 :param runtype: Type of testrun to run +40 :param datasets: list of dataset functions +41 :param algorithms: list of algorithm functions +42 :param metrics: list of metric functions +43 """ +44 if runtype == TestrunType.NORMAL_RUN: +45 controller = TestrunController() +46 else: +47 controller = ValidationRunController() +48 +49 function_map = { +50 "datasets": datasets, +51 "algorithms": algorithms, +52 "metrics": metrics +53 } +54 try: +55 result = controller.execute_run(function_map) +56 except Exception as e: +57 Logger.get_application_logger().critical("Unexpected error occurred during bench run. CPDBench was aborted.") +58 Logger.get_application_logger().critical(e) +59 logging.shutdown() +60 else: +61 self._output_result(result.get_result_as_dict()) +62 Logger.get_application_logger().info("CDPBench has finished. The following config has been used:") +63 Logger.get_application_logger().info(BenchConfig.get_complete_config()) +64 logging.shutdown() +65 +66 def _output_result(self, result_dict: dict) -> None: +67 """Outputs a result dict correctly on console and in a file +68 :param result_dict: the to be printed dict +69 """ +70 json_string = json.dumps(result_dict, indent=4, cls=ExtendedEncoder) +71 +72 # file output +73 with open(BenchConfig.result_file_name, 'w') as file: +74 file.write(json_string) +75 +76 # console output +77 print(json_string) +
Main controller for starting different types of test runs. +This is the basic class which is executed after initialization of the framework. +This controller then calls an ExecutionController implementation, which contains +the actual logic of a run.
+37 def execute_testrun(self, runtype: TestrunType, datasets: list, algorithms: list, metrics: list) -> None: +38 """Prepares and runs the required testrun +39 :param runtype: Type of testrun to run +40 :param datasets: list of dataset functions +41 :param algorithms: list of algorithm functions +42 :param metrics: list of metric functions +43 """ +44 if runtype == TestrunType.NORMAL_RUN: +45 controller = TestrunController() +46 else: +47 controller = ValidationRunController() +48 +49 function_map = { +50 "datasets": datasets, +51 "algorithms": algorithms, +52 "metrics": metrics +53 } +54 try: +55 result = controller.execute_run(function_map) +56 except Exception as e: +57 Logger.get_application_logger().critical("Unexpected error occurred during bench run. CPDBench was aborted.") +58 Logger.get_application_logger().critical(e) +59 logging.shutdown() +60 else: +61 self._output_result(result.get_result_as_dict()) +62 Logger.get_application_logger().info("CDPBench has finished. The following config has been used:") +63 Logger.get_application_logger().info(BenchConfig.get_complete_config()) +64 logging.shutdown() +
Prepares and runs the required testrun
+ +1import logging + 2import logging.handlers + 3import multiprocessing + 4import threading + 5from concurrent.futures import ProcessPoolExecutor + 6 + 7from cpdbench.control.CPDFullResult import CPDFullResult + 8from cpdbench.control.CPDResult import CPDResult + 9from cpdbench.control.DatasetExecutor import DatasetExecutor +10from cpdbench.control.ExecutionController import ExecutionController +11from cpdbench.utils import Logger, BenchConfig +12from tqdm import tqdm +13 +14 +15def _logger_thread(queue, logger): +16 while True: +17 record = queue.get() +18 if record is None: +19 break +20 logger.handle(record) +21 +22 +23def _create_ds_executor_and_run(dataset, algorithms, metrics, queue): +24 logger_name = 'cpdbench.' + dataset.get_task_name() +25 logger = logging.getLogger(logger_name) +26 logger.setLevel(logging.DEBUG) +27 logger.addHandler(logging.handlers.QueueHandler(queue)) +28 +29 ds_executor = DatasetExecutor(dataset, algorithms, metrics, logger) +30 try: +31 return ds_executor.execute() +32 except Exception as e: +33 logger.exception(e) +34 raise e +35 +36 +37class TestrunController(ExecutionController): +38 """An ExecutionController implementation for the standard run configuration. +39 As described in the paper, all given datasets, algorithms and metrics are +40 completely executed and all results are stored in a CPDFullResult. +41 """ +42 +43 def __init__(self): +44 self._logger = Logger.get_application_logger() +45 super().__init__(self._logger) +46 +47 def execute_run(self, methods: dict) -> CPDResult: +48 self._logger.info('Creating tasks...') +49 tasks = self._create_tasks(methods) +50 self._logger.info(f"{len(tasks['datasets']) + len(tasks['algorithms']) + len(tasks['metrics'])} tasks created") +51 +52 dataset_results = [] +53 run_result = CPDFullResult(list(map(lambda x: x.get_task_name(), tasks['datasets'])), +54 list(map(lambda x: x.get_task_name(), tasks['algorithms'])), +55 list(map(lambda x: x.get_task_name(), tasks['metrics']))) +56 q = multiprocessing.Manager().Queue() +57 error_list = [] +58 logging_thread = threading.Thread(target=_logger_thread, args=(q, self._logger)) +59 logging_thread.start() +60 +61 max_workers = None if BenchConfig.multiprocessing_enabled else 1 +62 with ProcessPoolExecutor(max_workers=max_workers) as executor: +63 for dataset in tasks["datasets"]: +64 dataset_results.append(executor.submit(_create_ds_executor_and_run, +65 dataset, +66 tasks["algorithms"], +67 tasks["metrics"], q)) +68 for i in tqdm(range(len(dataset_results)), desc="Processing datasets"): +69 j = 0 +70 while True: +71 ds_res = dataset_results[j] +72 try: +73 res = ds_res.result(2) +74 except Exception as e: +75 if e is TimeoutError: +76 error_list.append(e) +77 dataset_results.pop(j) +78 i += 1 +79 break +80 else: +81 run_result.add_dataset_result(res) +82 dataset_results.pop(j) +83 i += 1 +84 break +85 j += 1 +86 if j == len(dataset_results): +87 j = 0 +88 +89 q.put_nowait(None) +90 logging_thread.join() +91 for error in error_list: +92 self._logger.exception(error) +93 self._logger.info("Collected all datasets") +94 self._logger.info("Finished testrun. Printing results") +95 return run_result +
38class TestrunController(ExecutionController): +39 """An ExecutionController implementation for the standard run configuration. +40 As described in the paper, all given datasets, algorithms and metrics are +41 completely executed and all results are stored in a CPDFullResult. +42 """ +43 +44 def __init__(self): +45 self._logger = Logger.get_application_logger() +46 super().__init__(self._logger) +47 +48 def execute_run(self, methods: dict) -> CPDResult: +49 self._logger.info('Creating tasks...') +50 tasks = self._create_tasks(methods) +51 self._logger.info(f"{len(tasks['datasets']) + len(tasks['algorithms']) + len(tasks['metrics'])} tasks created") +52 +53 dataset_results = [] +54 run_result = CPDFullResult(list(map(lambda x: x.get_task_name(), tasks['datasets'])), +55 list(map(lambda x: x.get_task_name(), tasks['algorithms'])), +56 list(map(lambda x: x.get_task_name(), tasks['metrics']))) +57 q = multiprocessing.Manager().Queue() +58 error_list = [] +59 logging_thread = threading.Thread(target=_logger_thread, args=(q, self._logger)) +60 logging_thread.start() +61 +62 max_workers = None if BenchConfig.multiprocessing_enabled else 1 +63 with ProcessPoolExecutor(max_workers=max_workers) as executor: +64 for dataset in tasks["datasets"]: +65 dataset_results.append(executor.submit(_create_ds_executor_and_run, +66 dataset, +67 tasks["algorithms"], +68 tasks["metrics"], q)) +69 for i in tqdm(range(len(dataset_results)), desc="Processing datasets"): +70 j = 0 +71 while True: +72 ds_res = dataset_results[j] +73 try: +74 res = ds_res.result(2) +75 except Exception as e: +76 if e is TimeoutError: +77 error_list.append(e) +78 dataset_results.pop(j) +79 i += 1 +80 break +81 else: +82 run_result.add_dataset_result(res) +83 dataset_results.pop(j) +84 i += 1 +85 break +86 j += 1 +87 if j == len(dataset_results): +88 j = 0 +89 +90 q.put_nowait(None) +91 logging_thread.join() +92 for error in error_list: +93 self._logger.exception(error) +94 self._logger.info("Collected all datasets") +95 self._logger.info("Finished testrun. Printing results") +96 return run_result +
An ExecutionController implementation for the standard run configuration. +As described in the paper, all given datasets, algorithms and metrics are +completely executed and all results are stored in a CPDFullResult.
+48 def execute_run(self, methods: dict) -> CPDResult: +49 self._logger.info('Creating tasks...') +50 tasks = self._create_tasks(methods) +51 self._logger.info(f"{len(tasks['datasets']) + len(tasks['algorithms']) + len(tasks['metrics'])} tasks created") +52 +53 dataset_results = [] +54 run_result = CPDFullResult(list(map(lambda x: x.get_task_name(), tasks['datasets'])), +55 list(map(lambda x: x.get_task_name(), tasks['algorithms'])), +56 list(map(lambda x: x.get_task_name(), tasks['metrics']))) +57 q = multiprocessing.Manager().Queue() +58 error_list = [] +59 logging_thread = threading.Thread(target=_logger_thread, args=(q, self._logger)) +60 logging_thread.start() +61 +62 max_workers = None if BenchConfig.multiprocessing_enabled else 1 +63 with ProcessPoolExecutor(max_workers=max_workers) as executor: +64 for dataset in tasks["datasets"]: +65 dataset_results.append(executor.submit(_create_ds_executor_and_run, +66 dataset, +67 tasks["algorithms"], +68 tasks["metrics"], q)) +69 for i in tqdm(range(len(dataset_results)), desc="Processing datasets"): +70 j = 0 +71 while True: +72 ds_res = dataset_results[j] +73 try: +74 res = ds_res.result(2) +75 except Exception as e: +76 if e is TimeoutError: +77 error_list.append(e) +78 dataset_results.pop(j) +79 i += 1 +80 break +81 else: +82 run_result.add_dataset_result(res) +83 dataset_results.pop(j) +84 i += 1 +85 break +86 j += 1 +87 if j == len(dataset_results): +88 j = 0 +89 +90 q.put_nowait(None) +91 logging_thread.join() +92 for error in error_list: +93 self._logger.exception(error) +94 self._logger.info("Collected all datasets") +95 self._logger.info("Finished testrun. Printing results") +96 return run_result +
Executes the run implemented by this class.
+ +++A result object which can be handed to the user
+
1from cpdbench.control.CPDResult import CPDResult + 2from cpdbench.control.CPDValidationResult import CPDValidationResult + 3from cpdbench.control.ExecutionController import ExecutionController + 4from cpdbench.exception.ValidationException import DatasetValidationException, AlgorithmValidationException, \ + 5 MetricValidationException + 6from cpdbench.utils import Logger + 7 + 8 + 9class ValidationRunController(ExecutionController): +10 """A run configuration for validation runs. +11 These runs only execute algorithms with a (user defined) subset of the datasets, +12 and do not return the complete result sets. +13 """ +14 +15 def __init__(self): +16 self._logger = Logger.get_application_logger() +17 super().__init__(self._logger) +18 +19 def execute_run(self, methods: dict) -> CPDResult: +20 self._logger.info('Creating tasks...') +21 tasks = self._create_tasks(methods) +22 self._logger.info(f"{len(tasks['datasets']) + len(tasks['algorithms']) + len(tasks['metrics'])} tasks created") +23 +24 exception_list = [] +25 +26 self._logger.info('Begin validation') +27 for ds_task in tasks['datasets']: +28 try: +29 self._logger.debug(f"Validating {ds_task.get_task_name()}") +30 dataset = ds_task.validate_input() +31 except DatasetValidationException as e: +32 self._logger.debug(f"Error occurred when running {ds_task.get_task_name()}") +33 exception_list.append(e) +34 continue +35 self._logger.debug(f"Validated {ds_task.get_task_name()} without error") +36 data, ground_truth = dataset.get_validation_preview() +37 for algo_task in tasks['algorithms']: +38 try: +39 self._logger.debug(f"Validating {algo_task.get_task_name()}") +40 indexes, scores = algo_task.validate_input(data) +41 except AlgorithmValidationException as e: +42 self._logger.debug(f"Error occurred when running {algo_task.get_task_name()}") +43 exception_list.append(e) +44 continue +45 self._logger.debug(f"Validated {algo_task.get_task_name()} without error") +46 for metric_task in tasks['metrics']: +47 try: +48 self._logger.debug(f"Validating {metric_task.get_task_name()}") +49 metric_task.validate_input(indexes, scores, ground_truth) +50 except MetricValidationException as e: +51 self._logger.debug(f"Error occurred when running {metric_task.get_task_name()}") +52 exception_list.append(e) +53 continue +54 self._logger.debug(f"Validated {metric_task.get_task_name()} without error") +55 self._logger.info('Finished validation') +56 self._logger.info(f'{len(exception_list)} errors occurred') +57 validation_result = CPDValidationResult(exception_list, +58 list(map(lambda x: x.get_task_name(), tasks['datasets'])), +59 list(map(lambda x: x.get_task_name(), tasks['algorithms'])), +60 list(map(lambda x: x.get_task_name(), tasks['metrics']))) +61 for i in range(0, len(exception_list)): +62 self._logger.info(f"Error {i}") +63 self._logger.exception(exception_list[i]) +64 return validation_result +
10class ValidationRunController(ExecutionController): +11 """A run configuration for validation runs. +12 These runs only execute algorithms with a (user defined) subset of the datasets, +13 and do not return the complete result sets. +14 """ +15 +16 def __init__(self): +17 self._logger = Logger.get_application_logger() +18 super().__init__(self._logger) +19 +20 def execute_run(self, methods: dict) -> CPDResult: +21 self._logger.info('Creating tasks...') +22 tasks = self._create_tasks(methods) +23 self._logger.info(f"{len(tasks['datasets']) + len(tasks['algorithms']) + len(tasks['metrics'])} tasks created") +24 +25 exception_list = [] +26 +27 self._logger.info('Begin validation') +28 for ds_task in tasks['datasets']: +29 try: +30 self._logger.debug(f"Validating {ds_task.get_task_name()}") +31 dataset = ds_task.validate_input() +32 except DatasetValidationException as e: +33 self._logger.debug(f"Error occurred when running {ds_task.get_task_name()}") +34 exception_list.append(e) +35 continue +36 self._logger.debug(f"Validated {ds_task.get_task_name()} without error") +37 data, ground_truth = dataset.get_validation_preview() +38 for algo_task in tasks['algorithms']: +39 try: +40 self._logger.debug(f"Validating {algo_task.get_task_name()}") +41 indexes, scores = algo_task.validate_input(data) +42 except AlgorithmValidationException as e: +43 self._logger.debug(f"Error occurred when running {algo_task.get_task_name()}") +44 exception_list.append(e) +45 continue +46 self._logger.debug(f"Validated {algo_task.get_task_name()} without error") +47 for metric_task in tasks['metrics']: +48 try: +49 self._logger.debug(f"Validating {metric_task.get_task_name()}") +50 metric_task.validate_input(indexes, scores, ground_truth) +51 except MetricValidationException as e: +52 self._logger.debug(f"Error occurred when running {metric_task.get_task_name()}") +53 exception_list.append(e) +54 continue +55 self._logger.debug(f"Validated {metric_task.get_task_name()} without error") +56 self._logger.info('Finished validation') +57 self._logger.info(f'{len(exception_list)} errors occurred') +58 validation_result = CPDValidationResult(exception_list, +59 list(map(lambda x: x.get_task_name(), tasks['datasets'])), +60 list(map(lambda x: x.get_task_name(), tasks['algorithms'])), +61 list(map(lambda x: x.get_task_name(), tasks['metrics']))) +62 for i in range(0, len(exception_list)): +63 self._logger.info(f"Error {i}") +64 self._logger.exception(exception_list[i]) +65 return validation_result +
A run configuration for validation runs. +These runs only execute algorithms with a (user defined) subset of the datasets, +and do not return the complete result sets.
+20 def execute_run(self, methods: dict) -> CPDResult: +21 self._logger.info('Creating tasks...') +22 tasks = self._create_tasks(methods) +23 self._logger.info(f"{len(tasks['datasets']) + len(tasks['algorithms']) + len(tasks['metrics'])} tasks created") +24 +25 exception_list = [] +26 +27 self._logger.info('Begin validation') +28 for ds_task in tasks['datasets']: +29 try: +30 self._logger.debug(f"Validating {ds_task.get_task_name()}") +31 dataset = ds_task.validate_input() +32 except DatasetValidationException as e: +33 self._logger.debug(f"Error occurred when running {ds_task.get_task_name()}") +34 exception_list.append(e) +35 continue +36 self._logger.debug(f"Validated {ds_task.get_task_name()} without error") +37 data, ground_truth = dataset.get_validation_preview() +38 for algo_task in tasks['algorithms']: +39 try: +40 self._logger.debug(f"Validating {algo_task.get_task_name()}") +41 indexes, scores = algo_task.validate_input(data) +42 except AlgorithmValidationException as e: +43 self._logger.debug(f"Error occurred when running {algo_task.get_task_name()}") +44 exception_list.append(e) +45 continue +46 self._logger.debug(f"Validated {algo_task.get_task_name()} without error") +47 for metric_task in tasks['metrics']: +48 try: +49 self._logger.debug(f"Validating {metric_task.get_task_name()}") +50 metric_task.validate_input(indexes, scores, ground_truth) +51 except MetricValidationException as e: +52 self._logger.debug(f"Error occurred when running {metric_task.get_task_name()}") +53 exception_list.append(e) +54 continue +55 self._logger.debug(f"Validated {metric_task.get_task_name()} without error") +56 self._logger.info('Finished validation') +57 self._logger.info(f'{len(exception_list)} errors occurred') +58 validation_result = CPDValidationResult(exception_list, +59 list(map(lambda x: x.get_task_name(), tasks['datasets'])), +60 list(map(lambda x: x.get_task_name(), tasks['algorithms'])), +61 list(map(lambda x: x.get_task_name(), tasks['metrics']))) +62 for i in range(0, len(exception_list)): +63 self._logger.info(f"Error {i}") +64 self._logger.exception(exception_list[i]) +65 return validation_result +
Executes the run implemented by this class.
+ +++A result object which can be handed to the user
+
This package contains all classes representing CPD datasets. +This includes the abstract base class CPDDataset and two implementations
+1from numpy import ndarray, memmap + 2 + 3from cpdbench.dataset.CPDDataset import CPDDataset + 4 + 5 + 6class CPD2DFromFileDataset(CPDDataset): + 7 """Implementation of CPDDataset where the data source is large numpy array saved as file via memmap. + 8 With this implementation the framework can use very large datasets which are not completely loaded + 9 into the main memory. Instead numpy will lazy load all needed data points. +10 """ +11 +12 def __init__(self, file_path: str, dtype: str, ground_truths: list[int]): +13 """Constructor +14 :param file_path: The absolute or relative path to numpy file. +15 :param dtype: The data type in which the numpy array was saved. +16 :param ground_truths: The ground truth changepoints as integer list. +17 """ +18 self.file_path = file_path +19 self.dtype = dtype +20 self._array = None +21 self._ground_truths = ground_truths +22 +23 def init(self) -> None: +24 self._array = memmap(self.file_path, self.dtype, mode='r') +25 +26 def get_signal(self) -> tuple[ndarray, list[int]]: +27 return self._array, self._ground_truths +28 +29 def get_validation_preview(self) -> tuple[ndarray, list[int]]: +30 return self._array, self._ground_truths +
7class CPD2DFromFileDataset(CPDDataset): + 8 """Implementation of CPDDataset where the data source is large numpy array saved as file via memmap. + 9 With this implementation the framework can use very large datasets which are not completely loaded +10 into the main memory. Instead numpy will lazy load all needed data points. +11 """ +12 +13 def __init__(self, file_path: str, dtype: str, ground_truths: list[int]): +14 """Constructor +15 :param file_path: The absolute or relative path to numpy file. +16 :param dtype: The data type in which the numpy array was saved. +17 :param ground_truths: The ground truth changepoints as integer list. +18 """ +19 self.file_path = file_path +20 self.dtype = dtype +21 self._array = None +22 self._ground_truths = ground_truths +23 +24 def init(self) -> None: +25 self._array = memmap(self.file_path, self.dtype, mode='r') +26 +27 def get_signal(self) -> tuple[ndarray, list[int]]: +28 return self._array, self._ground_truths +29 +30 def get_validation_preview(self) -> tuple[ndarray, list[int]]: +31 return self._array, self._ground_truths +
Implementation of CPDDataset where the data source is large numpy array saved as file via memmap. +With this implementation the framework can use very large datasets which are not completely loaded +into the main memory. Instead numpy will lazy load all needed data points.
+13 def __init__(self, file_path: str, dtype: str, ground_truths: list[int]): +14 """Constructor +15 :param file_path: The absolute or relative path to numpy file. +16 :param dtype: The data type in which the numpy array was saved. +17 :param ground_truths: The ground truth changepoints as integer list. +18 """ +19 self.file_path = file_path +20 self.dtype = dtype +21 self._array = None +22 self._ground_truths = ground_truths +
Constructor
+ +Initialization method to prepare the dataset. +Examples: Open a file, open a db connection etc.
+Returns the timeseries as numpy array.
+ +++A 2D ndarray containing the timeseries (time x feature)
+
30 def get_validation_preview(self) -> tuple[ndarray, list[int]]: +31 return self._array, self._ground_truths +
Return a smaller part of the complete signal for fast runtime validation.
+ +++A 2D ndarray containing the timeseries (time x feature)
+
1from numpy import ndarray + 2 + 3from cpdbench.dataset.CPDDataset import CPDDataset + 4 + 5 + 6class CPD2DNdarrayDataset(CPDDataset): + 7 + 8 def get_validation_preview(self) -> tuple[ndarray, list[int]]: + 9 return self._ndarray, self._ground_truths +10 +11 def __init__(self, numpy_array, ground_truths): +12 self._ndarray = numpy_array +13 self._ground_truths = ground_truths +14 +15 def init(self) -> None: +16 pass +17 +18 def get_signal(self) -> tuple[ndarray, list[int]]: +19 return self._ndarray, self._ground_truths +
7class CPD2DNdarrayDataset(CPDDataset): + 8 + 9 def get_validation_preview(self) -> tuple[ndarray, list[int]]: +10 return self._ndarray, self._ground_truths +11 +12 def __init__(self, numpy_array, ground_truths): +13 self._ndarray = numpy_array +14 self._ground_truths = ground_truths +15 +16 def init(self) -> None: +17 pass +18 +19 def get_signal(self) -> tuple[ndarray, list[int]]: +20 return self._ndarray, self._ground_truths +
Abstract class representing a dataset.
+9 def get_validation_preview(self) -> tuple[ndarray, list[int]]: +10 return self._ndarray, self._ground_truths +
Return a smaller part of the complete signal for fast runtime validation.
+ +++A 2D ndarray containing the timeseries (time x feature)
+
Initialization method to prepare the dataset. +Examples: Open a file, open a db connection etc.
+19 def get_signal(self) -> tuple[ndarray, list[int]]: +20 return self._ndarray, self._ground_truths +
Returns the timeseries as numpy array.
+ +++A 2D ndarray containing the timeseries (time x feature)
+
1from abc import abstractmethod, ABC + 2from numpy import ndarray + 3 + 4 + 5class CPDDataset(ABC): + 6 """ + 7 Abstract class representing a dataset. + 8 """ + 9 +10 @abstractmethod +11 def init(self) -> None: +12 """ +13 Initialization method to prepare the dataset. +14 Examples: Open a file, open a db connection etc. +15 """ +16 pass +17 +18 @abstractmethod +19 def get_signal(self) -> tuple[ndarray, list[int]]: +20 """ +21 Returns the timeseries as numpy array. +22 :return: A 2D ndarray containing the timeseries (time x feature) +23 """ +24 pass +25 +26 @abstractmethod +27 def get_validation_preview(self) -> tuple[ndarray, list[int]]: +28 """Return a smaller part of the complete signal for fast runtime validation. +29 :return: A 2D ndarray containing the timeseries (time x feature) +30 """ +31 pass +
6class CPDDataset(ABC): + 7 """ + 8 Abstract class representing a dataset. + 9 """ +10 +11 @abstractmethod +12 def init(self) -> None: +13 """ +14 Initialization method to prepare the dataset. +15 Examples: Open a file, open a db connection etc. +16 """ +17 pass +18 +19 @abstractmethod +20 def get_signal(self) -> tuple[ndarray, list[int]]: +21 """ +22 Returns the timeseries as numpy array. +23 :return: A 2D ndarray containing the timeseries (time x feature) +24 """ +25 pass +26 +27 @abstractmethod +28 def get_validation_preview(self) -> tuple[ndarray, list[int]]: +29 """Return a smaller part of the complete signal for fast runtime validation. +30 :return: A 2D ndarray containing the timeseries (time x feature) +31 """ +32 pass +
Abstract class representing a dataset.
+11 @abstractmethod +12 def init(self) -> None: +13 """ +14 Initialization method to prepare the dataset. +15 Examples: Open a file, open a db connection etc. +16 """ +17 pass +
Initialization method to prepare the dataset. +Examples: Open a file, open a db connection etc.
+19 @abstractmethod +20 def get_signal(self) -> tuple[ndarray, list[int]]: +21 """ +22 Returns the timeseries as numpy array. +23 :return: A 2D ndarray containing the timeseries (time x feature) +24 """ +25 pass +
Returns the timeseries as numpy array.
+ +++A 2D ndarray containing the timeseries (time x feature)
+
27 @abstractmethod +28 def get_validation_preview(self) -> tuple[ndarray, list[int]]: +29 """Return a smaller part of the complete signal for fast runtime validation. +30 :return: A 2D ndarray containing the timeseries (time x feature) +31 """ +32 pass +
Return a smaller part of the complete signal for fast runtime validation.
+ +++A 2D ndarray containing the timeseries (time x feature)
+
1from changepoynt.algorithms.sst import SST + 2 + 3 + 4def numpy_array_accesses(dataset, array_indexes): + 5 indexes = [] + 6 for i in array_indexes: + 7 indexes.append(dataset[i]) + 8 confidences = [1 for _ in range(len(indexes))] + 9 return indexes, confidences +10 +11 +12def algorithm_execute_single_esst(signal): +13 """Uses SST as implemented in the changepoynt library as algorithm.""" +14 detector = SST(90, method='rsvd') +15 sig = signal[0] +16 res = detector.transform(sig) +17 indexes = [res.argmax()] +18 confidences = [1.0] +19 return indexes, confidences +20 +21 +22def algorithm_execute_single_esst(signal, window_length): +23 """Uses SST as implemented in the changepoynt library as algorithm.""" +24 detector = SST(window_length, method='rsvd') +25 sig = signal[0] +26 res = detector.transform(sig) +27 indexes = [res.argmax()] +28 confidences = [1.0] +29 return indexes, confidences +
23def algorithm_execute_single_esst(signal, window_length): +24 """Uses SST as implemented in the changepoynt library as algorithm.""" +25 detector = SST(window_length, method='rsvd') +26 sig = signal[0] +27 res = detector.transform(sig) +28 indexes = [res.argmax()] +29 confidences = [1.0] +30 return indexes, confidences +
Uses SST as implemented in the changepoynt library as algorithm.
+1import pathlib + 2 + 3import numpy as np + 4 + 5from cpdbench.dataset.CPD2DFromFileDataset import CPD2DFromFileDataset + 6from cpdbench.dataset.CPD2DNdarrayDataset import CPD2DNdarrayDataset + 7 + 8 + 9def get_extreme_large_dataset_from_file(): +10 path = pathlib.Path(__file__).parent.resolve() +11 path = path.joinpath("data", "very_big_numpy_file.dat") +12 dataset = CPD2DFromFileDataset(str(path), "float32", [5, 245, 255, 256, 25]) +13 return dataset +14 +15def dataset_get_apple_dataset(): +16 raw_data = np.load("../../../data/apple.npy") +17 timeseries = raw_data[:, 0] +18 reshaped_ts = np.reshape(timeseries, [1, timeseries.size]) +19 return CPD2DNdarrayDataset(reshaped_ts, [337]) +20 +21 +22def dataset_get_bitcoin_dataset(): +23 raw_data = np.load("../../../data/bitcoin.npy") +24 timeseries = raw_data[:, 0] +25 reshaped_ts = np.reshape(timeseries, [1, timeseries.size]) +26 return CPD2DNdarrayDataset(reshaped_ts, [569]) +
1def metric_accuracy_in_allowed_windows(indexes, scores, ground_truth, *, window_size): + 2 """Calculate the accuracy with a small deviation window. + 3 The result is the percentage of ground truth values, for which the algorithm got at least one fitting index in the + 4 surrounding window. The scores are ignored. + 5 """ + 6 accuracy = 0 + 7 for gt in ground_truth: + 8 range_of_gt = range(int(gt - (window_size / 2)), int(gt + (window_size / 2))) + 9 hits = [i for i in indexes if i in range_of_gt] +10 if len(hits) > 0: +11 accuracy += (1 / len(ground_truth)) +12 return accuracy +
3def metric_accuracy_in_allowed_windows(indexes, scores, ground_truth, *, window_size): + 4 """Calculate the accuracy with a small deviation window. + 5 The result is the percentage of ground truth values, for which the algorithm got at least one fitting index in the + 6 surrounding window. The scores are ignored. + 7 """ + 8 accuracy = 0 + 9 for gt in ground_truth: +10 range_of_gt = range(int(gt - (window_size / 2)), int(gt + (window_size / 2))) +11 hits = [i for i in indexes if i in range_of_gt] +12 if len(hits) > 0: +13 accuracy += (1 / len(ground_truth)) +14 return accuracy +
Calculate the accuracy with a small deviation window. +The result is the percentage of ground truth values, for which the algorithm got at least one fitting index in the +surrounding window. The scores are ignored.
+1from cpdbench.CPDBench import CPDBench + 2import cpdbench.examples.ExampleDatasets as example_datasets + 3import cpdbench.examples.ExampleAlgorithms as example_algorithms + 4import cpdbench.examples.ExampleMetrics as example_metrics + 5 + 6cpdb = CPDBench() + 7 + 8 + 9@cpdb.dataset +10def get_apple_dataset(): +11 return example_datasets.dataset_get_apple_dataset() +12 +13 +14@cpdb.dataset +15def get_bitcoin_dataset(): +16 return example_datasets.dataset_get_bitcoin_dataset() +17 +18 +19@cpdb.algorithm +20def execute_esst_test(signal, *, window_length): +21 return example_algorithms.algorithm_execute_single_esst(signal, window_length) +22 +23 +24@cpdb.metric +25def calc_accuracy(indexes, scores, ground_truth, *, window_size): +26 return example_metrics.metric_accuracy_in_allowed_windows(indexes, scores, ground_truth, window_size=window_size) +27 +28 +29if __name__ == '__main__': +30 cpdb.start("configs/parametersConfig.yml") +
1from cpdbench.CPDBench import CPDBench + 2import cpdbench.examples.ExampleDatasets as example_datasets + 3import cpdbench.examples.ExampleAlgorithms as example_algorithms + 4import cpdbench.examples.ExampleMetrics as example_metrics + 5 + 6cpdb = CPDBench() + 7 + 8 + 9@cpdb.dataset +10def get_apple_dataset(): +11 return example_datasets.dataset_get_apple_dataset() +12 +13 +14@cpdb.dataset +15def get_bitcoin_dataset(): +16 return example_datasets.dataset_get_bitcoin_dataset() +17 +18 +19@cpdb.algorithm +20def execute_esst_test(signal): +21 return example_algorithms.algorithm_execute_single_esst(signal) +22 +23 +24@cpdb.metric +25def calc_accuracy(indexes, scores, ground_truth): +26 return example_metrics.metric_accuracy_in_allowed_windows(indexes, scores, ground_truth, window_size=25) +27 +28 +29if __name__ == '__main__': +30 cpdb.start() +
1from cpdbench.examples.ExampleDatasets import get_extreme_large_dataset_from_file + 2from cpdbench.examples.ExampleAlgorithms import numpy_array_accesses + 3from cpdbench.examples.ExampleMetrics import metric_accuracy_in_allowed_windows + 4from cpdbench.CPDBench import CPDBench + 5import pathlib + 6 + 7cpdb = CPDBench() + 8 + 9 +10@cpdb.dataset +11def get_large_dataset(): +12 return get_extreme_large_dataset_from_file() +13 +14 +15@cpdb.algorithm +16def execute_algorithm(dataset, *, array_indexes): +17 return numpy_array_accesses(dataset, array_indexes) +18 +19 +20@cpdb.metric +21def compute_metric(indexes, confidences, ground_truths): +22 return metric_accuracy_in_allowed_windows(indexes, confidences, ground_truths, window_size=20) +23 +24 +25if __name__ == '__main__': +26 path = pathlib.Path(__file__).parent.resolve() +27 path = path.joinpath("configs", "VeryLargeDatasetConfig.yml") +28 cpdb.start(config_file=str(path)) +
This package contains all custom exception classes +used by the framework.
+1from cpdbench.exception.CPDExecutionException import CPDExecutionException + 2 + 3 + 4class AlgorithmExecutionException(CPDExecutionException): + 5 """Exception type when the execution of an algorithm on a dataset has failed""" + 6 + 7 standard_msg = 'Error while executing the algorithm {0} on dataset {1}' + 8 + 9 def __init__(self, algorithm_function, dataset_function): +10 super().__init__(self.standard_msg.format(algorithm_function, dataset_function)) +
5class AlgorithmExecutionException(CPDExecutionException): + 6 """Exception type when the execution of an algorithm on a dataset has failed""" + 7 + 8 standard_msg = 'Error while executing the algorithm {0} on dataset {1}' + 9 +10 def __init__(self, algorithm_function, dataset_function): +11 super().__init__(self.standard_msg.format(algorithm_function, dataset_function)) +
Exception type when the execution of an algorithm on a dataset has failed
+2class CPDExecutionException(Exception): +3 """General Exception type when something goes wrong in dataset fetching, algorithm execution or metric +4 calculation.""" +5 def __init__(self, message): +6 super().__init__(message) +
General Exception type when something goes wrong in dataset fetching, algorithm execution or metric +calculation.
+1class ConfigurationException(Exception): + 2 """General error for inconsistencies and errors in the given config file.""" + 3 exc_message = "Error in configuration file: Invalid value for {0}, using default value." + 4 + 5 def __init__(self, config_variable): + 6 super().__init__(self.exc_message.format(config_variable)) + 7 + 8 + 9class ConfigurationFileNotFoundException(Exception): +10 """Error if a given config file path does not exist""" +11 exc_message = "Given config file path [{0}] does not exist. Using default config values." +12 +13 def __init__(self, config_variable): +14 super().__init__(self.exc_message.format(config_variable)) +
2class ConfigurationException(Exception): +3 """General error for inconsistencies and errors in the given config file.""" +4 exc_message = "Error in configuration file: Invalid value for {0}, using default value." +5 +6 def __init__(self, config_variable): +7 super().__init__(self.exc_message.format(config_variable)) +
General error for inconsistencies and errors in the given config file.
+10class ConfigurationFileNotFoundException(Exception): +11 """Error if a given config file path does not exist""" +12 exc_message = "Given config file path [{0}] does not exist. Using default config values." +13 +14 def __init__(self, config_variable): +15 super().__init__(self.exc_message.format(config_variable)) +
Error if a given config file path does not exist
+1from cpdbench.exception.CPDExecutionException import CPDExecutionException + 2 + 3 + 4class DatasetFetchException(CPDExecutionException): + 5 """Exception type when something goes wrong while loading a dataset""" + 6 + 7 def __init__(self, message): + 8 super().__init__(message) + 9 +10 +11class CPDDatasetCreationException(DatasetFetchException): +12 """Exception type when the initialization and creation of the CPDDataset object has failed""" +13 standard_msg_create_dataset = "Error while creating the CPDDataset object with the {0} function" +14 +15 def __init__(self, dataset_function): +16 # function_name = get_name_of_function(dataset_function) +17 super().__init__(self.standard_msg_create_dataset.format(dataset_function)) +18 +19 +20class FeatureLoadingException(DatasetFetchException): +21 """Exception type when the loading of a feature of a CPDDataset has failed""" +22 standard_msg_load_feature = "Error while loading feature {0} of the CPDDataset from function {1}" +23 +24 def __init__(self, dataset_function, feature): +25 # function_name = get_name_of_function(dataset_function) +26 super().__init__(self.standard_msg_load_feature.format(feature, dataset_function)) +27 +28 +29class SignalLoadingException(DatasetFetchException): +30 """Exception type when the loading of a signal of a CPDDataset has failed""" +31 standard_msg_load_signal = "Error while loading the signal of the CPDDataset from function {0}" +32 +33 def __init__(self, dataset_function): +34 super().__init__(self.standard_msg_load_signal.format(dataset_function)) +
5class DatasetFetchException(CPDExecutionException): +6 """Exception type when something goes wrong while loading a dataset""" +7 +8 def __init__(self, message): +9 super().__init__(message) +
Exception type when something goes wrong while loading a dataset
+12class CPDDatasetCreationException(DatasetFetchException): +13 """Exception type when the initialization and creation of the CPDDataset object has failed""" +14 standard_msg_create_dataset = "Error while creating the CPDDataset object with the {0} function" +15 +16 def __init__(self, dataset_function): +17 # function_name = get_name_of_function(dataset_function) +18 super().__init__(self.standard_msg_create_dataset.format(dataset_function)) +
Exception type when the initialization and creation of the CPDDataset object has failed
+21class FeatureLoadingException(DatasetFetchException): +22 """Exception type when the loading of a feature of a CPDDataset has failed""" +23 standard_msg_load_feature = "Error while loading feature {0} of the CPDDataset from function {1}" +24 +25 def __init__(self, dataset_function, feature): +26 # function_name = get_name_of_function(dataset_function) +27 super().__init__(self.standard_msg_load_feature.format(feature, dataset_function)) +
Exception type when the loading of a feature of a CPDDataset has failed
+30class SignalLoadingException(DatasetFetchException): +31 """Exception type when the loading of a signal of a CPDDataset has failed""" +32 standard_msg_load_signal = "Error while loading the signal of the CPDDataset from function {0}" +33 +34 def __init__(self, dataset_function): +35 super().__init__(self.standard_msg_load_signal.format(dataset_function)) +
Exception type when the loading of a signal of a CPDDataset has failed
+1from cpdbench.exception.CPDExecutionException import CPDExecutionException + 2 + 3 + 4class MetricExecutionException(CPDExecutionException): + 5 """Exception type when the execution of a metric on an algorithm result has failed""" + 6 + 7 standard_msg = 'Error while executing the metric {0} on algorithm {1} (dataset {2})' + 8 + 9 def __init__(self, metric_function, algorithm_function, dataset_function): +10 super().__init__(self.standard_msg.format(metric_function, algorithm_function, dataset_function)) +
5class MetricExecutionException(CPDExecutionException): + 6 """Exception type when the execution of a metric on an algorithm result has failed""" + 7 + 8 standard_msg = 'Error while executing the metric {0} on algorithm {1} (dataset {2})' + 9 +10 def __init__(self, metric_function, algorithm_function, dataset_function): +11 super().__init__(self.standard_msg.format(metric_function, algorithm_function, dataset_function)) +
Exception type when the execution of a metric on an algorithm result has failed
+2class ResultSetInconsistentException(Exception): +3 """Exception type for inconsistencies in a result object. +4 For example when an algorithm result is to be added for an algorithm which does not exist.""" +5 pass +
Exception type for inconsistencies in a result object. +For example when an algorithm result is to be added for an algorithm which does not exist.
+1class UserParameterDoesNotExistException(Exception): +2 """Exception type when a needed user parameter in a dataset, algorithm or metric does not exist in the config +3 file.""" +4 msg_text = "The user parameter [{0}] is needed for running [{1}], but does not exist in the given config file." +5 +6 def __init__(self, param_name, function_name): +7 super().__init__(self.msg_text.format(param_name, function_name)) +
2class UserParameterDoesNotExistException(Exception): +3 """Exception type when a needed user parameter in a dataset, algorithm or metric does not exist in the config +4 file.""" +5 msg_text = "The user parameter [{0}] is needed for running [{1}], but does not exist in the given config file." +6 +7 def __init__(self, param_name, function_name): +8 super().__init__(self.msg_text.format(param_name, function_name)) +
Exception type when a needed user parameter in a dataset, algorithm or metric does not exist in the config +file.
+1class ValidationException(Exception): + 2 """General exception type when some validation went wrong.""" + 3 pass + 4 + 5 + 6class InputValidationException(ValidationException): + 7 """More specific validation exception when something about the input parameters is wrong.""" + 8 pass + 9 +10 +11class AlgorithmValidationException(ValidationException): +12 """Validation exception when runtime validation of an algorithm fails.""" +13 pass +14 +15 +16class MetricValidationException(ValidationException): +17 """Validation exception when runtime validation of a metric fails.""" +18 pass +19 +20 +21class DatasetValidationException(ValidationException): +22 """Validation exception when runtime validation of a dataset fails.""" +23 pass +
2class ValidationException(Exception): +3 """General exception type when some validation went wrong.""" +4 pass +
General exception type when some validation went wrong.
+7class InputValidationException(ValidationException): +8 """More specific validation exception when something about the input parameters is wrong.""" +9 pass +
More specific validation exception when something about the input parameters is wrong.
+12class AlgorithmValidationException(ValidationException): +13 """Validation exception when runtime validation of an algorithm fails.""" +14 pass +
Validation exception when runtime validation of an algorithm fails.
+17class MetricValidationException(ValidationException): +18 """Validation exception when runtime validation of a metric fails.""" +19 pass +
Validation exception when runtime validation of a metric fails.
+22class DatasetValidationException(ValidationException): +23 """Validation exception when runtime validation of a dataset fails.""" +24 pass +
Validation exception when runtime validation of a dataset fails.
+This package contains the Task abstract class, its implementations, +and the factory to create task objects.
+1from collections.abc import Iterable + 2 + 3from numpy import ndarray + 4 + 5from cpdbench.exception.ValidationException import InputValidationException, AlgorithmValidationException + 6from cpdbench.task.Task import Task + 7 + 8import inspect + 9 +10from cpdbench.utils.Utils import get_name_of_function +11 +12 +13class AlgorithmExecutionTask(Task): +14 def __init__(self, function, counter, param_dict=None): +15 super().__init__(function, counter, param_dict) +16 +17 def validate_task(self) -> None: +18 # Check number of args +19 full_arg_spec = inspect.getfullargspec(self._function) +20 if len(full_arg_spec.args) != 1: +21 # Wrong number of arguments +22 function_name = get_name_of_function(self._function) +23 raise InputValidationException(f"The number of arguments for the algorithm task '{function_name}' " +24 f"is {len(full_arg_spec.args)} but should be " +25 "1: (signal)") +26 +27 def validate_input(self, data: ndarray) -> tuple[Iterable, Iterable]: +28 try: +29 alg_res_index, alg_res_scores = self._function(data) +30 except Exception as e: +31 raise AlgorithmValidationException(f"The validation of {get_name_of_function(self._function)} failed.") \ +32 from e +33 else: +34 return alg_res_index, alg_res_scores +35 +36 def execute(self, data: ndarray) -> tuple[Iterable, Iterable]: +37 alg_res_index, alg_res_scores = self._function(data) +38 return alg_res_index, alg_res_scores +39 +40 def get_task_name(self) -> str: +41 return f"algorithm:{self._task_name}" +
14class AlgorithmExecutionTask(Task): +15 def __init__(self, function, counter, param_dict=None): +16 super().__init__(function, counter, param_dict) +17 +18 def validate_task(self) -> None: +19 # Check number of args +20 full_arg_spec = inspect.getfullargspec(self._function) +21 if len(full_arg_spec.args) != 1: +22 # Wrong number of arguments +23 function_name = get_name_of_function(self._function) +24 raise InputValidationException(f"The number of arguments for the algorithm task '{function_name}' " +25 f"is {len(full_arg_spec.args)} but should be " +26 "1: (signal)") +27 +28 def validate_input(self, data: ndarray) -> tuple[Iterable, Iterable]: +29 try: +30 alg_res_index, alg_res_scores = self._function(data) +31 except Exception as e: +32 raise AlgorithmValidationException(f"The validation of {get_name_of_function(self._function)} failed.") \ +33 from e +34 else: +35 return alg_res_index, alg_res_scores +36 +37 def execute(self, data: ndarray) -> tuple[Iterable, Iterable]: +38 alg_res_index, alg_res_scores = self._function(data) +39 return alg_res_index, alg_res_scores +40 +41 def get_task_name(self) -> str: +42 return f"algorithm:{self._task_name}" +
Abstract class for a Task object which is a work package to be executed by the framework. +A task has a name, can be validated, and executed, and can have some parameters.
+15 def __init__(self, function, counter, param_dict=None): +16 super().__init__(function, counter, param_dict) +
General constructor for all task objects.
+ +18 def validate_task(self) -> None: +19 # Check number of args +20 full_arg_spec = inspect.getfullargspec(self._function) +21 if len(full_arg_spec.args) != 1: +22 # Wrong number of arguments +23 function_name = get_name_of_function(self._function) +24 raise InputValidationException(f"The number of arguments for the algorithm task '{function_name}' " +25 f"is {len(full_arg_spec.args)} but should be " +26 "1: (signal)") +
Validates the task statically by checking task details before running it. +Throws an exception if the validation fails.
+28 def validate_input(self, data: ndarray) -> tuple[Iterable, Iterable]: +29 try: +30 alg_res_index, alg_res_scores = self._function(data) +31 except Exception as e: +32 raise AlgorithmValidationException(f"The validation of {get_name_of_function(self._function)} failed.") \ +33 from e +34 else: +35 return alg_res_index, alg_res_scores +
Validates the task in combination with some input arguments. +Throws an exception if the validation fails.
+37 def execute(self, data: ndarray) -> tuple[Iterable, Iterable]: +38 alg_res_index, alg_res_scores = self._function(data) +39 return alg_res_index, alg_res_scores +
Executes the task. Can take an arbitrary number of arguments and can produce any result.
+Returns a descriptive name for the task.
+ +++task name as string
+
1import inspect + 2 + 3from cpdbench.exception.ValidationException import DatasetValidationException, InputValidationException + 4from cpdbench.dataset import CPDDataset + 5from cpdbench.task.Task import Task + 6 + 7from cpdbench.utils.Utils import get_name_of_function + 8 + 9 +10class DatasetFetchTask(Task): +11 def __init__(self, function, counter, param_dict=None): +12 super().__init__(function, counter, param_dict) +13 +14 def validate_task(self) -> None: +15 # Check number of args +16 full_arg_spec = inspect.getfullargspec(self._function) +17 if len(full_arg_spec.args) > 0: +18 # Wrong number of arguments +19 function_name = get_name_of_function(self._function) +20 raise InputValidationException("The number of arguments for the dataset task '{0}' is {1} but should be 0." +21 .format(function_name, len(full_arg_spec.args))) +22 +23 def validate_input(self, *args) -> CPDDataset: +24 try: +25 dataset: CPDDataset = self._function() +26 dataset.init() +27 except Exception as e: +28 raise DatasetValidationException(f"The validation of {get_name_of_function(self._function)} failed.") \ +29 from e # TODO: Funktioniert das noch? +30 else: +31 return dataset +32 +33 def execute(self) -> CPDDataset: +34 dataset: CPDDataset = self._function() +35 dataset.init() +36 return dataset +37 +38 def get_task_name(self) -> str: +39 return f"dataset:{self._task_name}" +
11class DatasetFetchTask(Task): +12 def __init__(self, function, counter, param_dict=None): +13 super().__init__(function, counter, param_dict) +14 +15 def validate_task(self) -> None: +16 # Check number of args +17 full_arg_spec = inspect.getfullargspec(self._function) +18 if len(full_arg_spec.args) > 0: +19 # Wrong number of arguments +20 function_name = get_name_of_function(self._function) +21 raise InputValidationException("The number of arguments for the dataset task '{0}' is {1} but should be 0." +22 .format(function_name, len(full_arg_spec.args))) +23 +24 def validate_input(self, *args) -> CPDDataset: +25 try: +26 dataset: CPDDataset = self._function() +27 dataset.init() +28 except Exception as e: +29 raise DatasetValidationException(f"The validation of {get_name_of_function(self._function)} failed.") \ +30 from e # TODO: Funktioniert das noch? +31 else: +32 return dataset +33 +34 def execute(self) -> CPDDataset: +35 dataset: CPDDataset = self._function() +36 dataset.init() +37 return dataset +38 +39 def get_task_name(self) -> str: +40 return f"dataset:{self._task_name}" +
Abstract class for a Task object which is a work package to be executed by the framework. +A task has a name, can be validated, and executed, and can have some parameters.
+12 def __init__(self, function, counter, param_dict=None): +13 super().__init__(function, counter, param_dict) +
General constructor for all task objects.
+ +15 def validate_task(self) -> None: +16 # Check number of args +17 full_arg_spec = inspect.getfullargspec(self._function) +18 if len(full_arg_spec.args) > 0: +19 # Wrong number of arguments +20 function_name = get_name_of_function(self._function) +21 raise InputValidationException("The number of arguments for the dataset task '{0}' is {1} but should be 0." +22 .format(function_name, len(full_arg_spec.args))) +
Validates the task statically by checking task details before running it. +Throws an exception if the validation fails.
+24 def validate_input(self, *args) -> CPDDataset: +25 try: +26 dataset: CPDDataset = self._function() +27 dataset.init() +28 except Exception as e: +29 raise DatasetValidationException(f"The validation of {get_name_of_function(self._function)} failed.") \ +30 from e # TODO: Funktioniert das noch? +31 else: +32 return dataset +
Validates the task in combination with some input arguments. +Throws an exception if the validation fails.
+34 def execute(self) -> CPDDataset: +35 dataset: CPDDataset = self._function() +36 dataset.init() +37 return dataset +
Executes the task. Can take an arbitrary number of arguments and can produce any result.
+Returns a descriptive name for the task.
+ +++task name as string
+
1import inspect + 2from collections.abc import Iterable + 3 + 4from cpdbench.exception.ValidationException import InputValidationException, MetricValidationException + 5from cpdbench.task.Task import Task + 6from cpdbench.utils.Utils import get_name_of_function + 7 + 8 + 9class MetricExecutionTask(Task): +10 def __init__(self, function, counter, param_dict=None): +11 super().__init__(function, counter, param_dict) +12 +13 def execute(self, indexes: Iterable, scores: Iterable, ground_truths: Iterable) -> float: +14 return self._function(indexes, scores, ground_truths) +15 +16 def validate_task(self) -> None: +17 # Check number of args +18 full_arg_spec = inspect.getfullargspec(self._function) +19 if len(full_arg_spec.args) != 3: +20 # Wrong number of arguments +21 function_name = get_name_of_function(self._function) +22 raise InputValidationException("The number of arguments for the metric task '{0}' is {1} but should be " +23 "3: (indexes, scores, ground_truth)" +24 .format(function_name, len(full_arg_spec.args))) +25 +26 def validate_input(self, indexes: Iterable, scores: Iterable, ground_truths: Iterable) -> float: +27 try: +28 res = self._function(indexes, scores, ground_truths) +29 except Exception as e: +30 raise MetricValidationException(f"The validation of {get_name_of_function(self._function)} failed.") \ +31 from e +32 else: +33 return res +34 +35 def get_task_name(self) -> str: +36 return f"metric:{self._task_name}" +
10class MetricExecutionTask(Task): +11 def __init__(self, function, counter, param_dict=None): +12 super().__init__(function, counter, param_dict) +13 +14 def execute(self, indexes: Iterable, scores: Iterable, ground_truths: Iterable) -> float: +15 return self._function(indexes, scores, ground_truths) +16 +17 def validate_task(self) -> None: +18 # Check number of args +19 full_arg_spec = inspect.getfullargspec(self._function) +20 if len(full_arg_spec.args) != 3: +21 # Wrong number of arguments +22 function_name = get_name_of_function(self._function) +23 raise InputValidationException("The number of arguments for the metric task '{0}' is {1} but should be " +24 "3: (indexes, scores, ground_truth)" +25 .format(function_name, len(full_arg_spec.args))) +26 +27 def validate_input(self, indexes: Iterable, scores: Iterable, ground_truths: Iterable) -> float: +28 try: +29 res = self._function(indexes, scores, ground_truths) +30 except Exception as e: +31 raise MetricValidationException(f"The validation of {get_name_of_function(self._function)} failed.") \ +32 from e +33 else: +34 return res +35 +36 def get_task_name(self) -> str: +37 return f"metric:{self._task_name}" +
Abstract class for a Task object which is a work package to be executed by the framework. +A task has a name, can be validated, and executed, and can have some parameters.
+11 def __init__(self, function, counter, param_dict=None): +12 super().__init__(function, counter, param_dict) +
General constructor for all task objects.
+ +14 def execute(self, indexes: Iterable, scores: Iterable, ground_truths: Iterable) -> float: +15 return self._function(indexes, scores, ground_truths) +
Executes the task. Can take an arbitrary number of arguments and can produce any result.
+17 def validate_task(self) -> None: +18 # Check number of args +19 full_arg_spec = inspect.getfullargspec(self._function) +20 if len(full_arg_spec.args) != 3: +21 # Wrong number of arguments +22 function_name = get_name_of_function(self._function) +23 raise InputValidationException("The number of arguments for the metric task '{0}' is {1} but should be " +24 "3: (indexes, scores, ground_truth)" +25 .format(function_name, len(full_arg_spec.args))) +
Validates the task statically by checking task details before running it. +Throws an exception if the validation fails.
+27 def validate_input(self, indexes: Iterable, scores: Iterable, ground_truths: Iterable) -> float: +28 try: +29 res = self._function(indexes, scores, ground_truths) +30 except Exception as e: +31 raise MetricValidationException(f"The validation of {get_name_of_function(self._function)} failed.") \ +32 from e +33 else: +34 return res +
Validates the task in combination with some input arguments. +Throws an exception if the validation fails.
+Returns a descriptive name for the task.
+ +++task name as string
+
1from abc import ABC, abstractmethod + 2from enum import Enum + 3import functools + 4import uuid + 5 + 6 + 7class TaskType(Enum): + 8 """Enum of pre-defined task types needed for the CPDBench""" + 9 DATASET_FETCH = 1 +10 ALGORITHM_EXECUTION = 2 +11 METRIC_EXECUTION = 3 +12 +13 +14class Task(ABC): +15 """Abstract class for a Task object which is a work package to be executed by the framework. +16 A task has a name, can be validated, and executed, and can have some parameters. +17 """ +18 +19 def __init__(self, function, counter=0, param_dict=None): +20 """General constructor for all task objects. +21 :param function: The function handle to be executed as task content +22 :param counter: A number which is appended to the task name. Useful if multiple tasks with the same name exist. +23 :param param_dict: An optional parameter dictionary for the task +24 """ +25 self._function = function +26 if isinstance(function, functools.partial): +27 self._function_name = function.func.__name__ +28 else: +29 self._function_name = function.__name__ +30 self._task_name = self._function_name + ":" + str(counter) +31 self._param_dict = param_dict +32 +33 @abstractmethod +34 def execute(self, *args) -> any: +35 """Executes the task. Can take an arbitrary number of arguments and can produce any result.""" +36 pass +37 +38 @abstractmethod +39 def validate_task(self) -> None: +40 """Validates the task statically by checking task details before running it. +41 Throws an exception if the validation fails. +42 """ +43 pass +44 +45 @abstractmethod +46 def validate_input(self, *args) -> any: +47 """Validates the task in combination with some input arguments. +48 Throws an exception if the validation fails. +49 """ +50 pass +51 +52 @abstractmethod +53 def get_task_name(self) -> str: +54 """Returns a descriptive name for the task. +55 :return: task name as string +56 """ +57 pass +58 +59 def get_param_dict(self) -> dict: +60 """Returns the parameters this task contains. +61 :return: the parameters as dictionary +62 """ +63 return self._param_dict +
8class TaskType(Enum): + 9 """Enum of pre-defined task types needed for the CPDBench""" +10 DATASET_FETCH = 1 +11 ALGORITHM_EXECUTION = 2 +12 METRIC_EXECUTION = 3 +
Enum of pre-defined task types needed for the CPDBench
+15class Task(ABC): +16 """Abstract class for a Task object which is a work package to be executed by the framework. +17 A task has a name, can be validated, and executed, and can have some parameters. +18 """ +19 +20 def __init__(self, function, counter=0, param_dict=None): +21 """General constructor for all task objects. +22 :param function: The function handle to be executed as task content +23 :param counter: A number which is appended to the task name. Useful if multiple tasks with the same name exist. +24 :param param_dict: An optional parameter dictionary for the task +25 """ +26 self._function = function +27 if isinstance(function, functools.partial): +28 self._function_name = function.func.__name__ +29 else: +30 self._function_name = function.__name__ +31 self._task_name = self._function_name + ":" + str(counter) +32 self._param_dict = param_dict +33 +34 @abstractmethod +35 def execute(self, *args) -> any: +36 """Executes the task. Can take an arbitrary number of arguments and can produce any result.""" +37 pass +38 +39 @abstractmethod +40 def validate_task(self) -> None: +41 """Validates the task statically by checking task details before running it. +42 Throws an exception if the validation fails. +43 """ +44 pass +45 +46 @abstractmethod +47 def validate_input(self, *args) -> any: +48 """Validates the task in combination with some input arguments. +49 Throws an exception if the validation fails. +50 """ +51 pass +52 +53 @abstractmethod +54 def get_task_name(self) -> str: +55 """Returns a descriptive name for the task. +56 :return: task name as string +57 """ +58 pass +59 +60 def get_param_dict(self) -> dict: +61 """Returns the parameters this task contains. +62 :return: the parameters as dictionary +63 """ +64 return self._param_dict +
Abstract class for a Task object which is a work package to be executed by the framework. +A task has a name, can be validated, and executed, and can have some parameters.
+20 def __init__(self, function, counter=0, param_dict=None): +21 """General constructor for all task objects. +22 :param function: The function handle to be executed as task content +23 :param counter: A number which is appended to the task name. Useful if multiple tasks with the same name exist. +24 :param param_dict: An optional parameter dictionary for the task +25 """ +26 self._function = function +27 if isinstance(function, functools.partial): +28 self._function_name = function.func.__name__ +29 else: +30 self._function_name = function.__name__ +31 self._task_name = self._function_name + ":" + str(counter) +32 self._param_dict = param_dict +
General constructor for all task objects.
+ +34 @abstractmethod +35 def execute(self, *args) -> any: +36 """Executes the task. Can take an arbitrary number of arguments and can produce any result.""" +37 pass +
Executes the task. Can take an arbitrary number of arguments and can produce any result.
+39 @abstractmethod +40 def validate_task(self) -> None: +41 """Validates the task statically by checking task details before running it. +42 Throws an exception if the validation fails. +43 """ +44 pass +
Validates the task statically by checking task details before running it. +Throws an exception if the validation fails.
+46 @abstractmethod +47 def validate_input(self, *args) -> any: +48 """Validates the task in combination with some input arguments. +49 Throws an exception if the validation fails. +50 """ +51 pass +
Validates the task in combination with some input arguments. +Throws an exception if the validation fails.
+53 @abstractmethod +54 def get_task_name(self) -> str: +55 """Returns a descriptive name for the task. +56 :return: task name as string +57 """ +58 pass +
Returns a descriptive name for the task.
+ +++task name as string
+
60 def get_param_dict(self) -> dict: +61 """Returns the parameters this task contains. +62 :return: the parameters as dictionary +63 """ +64 return self._param_dict +
Returns the parameters this task contains.
+ +++the parameters as dictionary
+
1from typing import Callable + 2import inspect + 3 + 4from cpdbench.exception.UserParameterDoesNotExistException import UserParameterDoesNotExistException + 5from cpdbench.task.AlgorithmExecutionTask import AlgorithmExecutionTask + 6from cpdbench.task.DatasetFetchTask import DatasetFetchTask + 7from cpdbench.task.MetricExecutionTask import MetricExecutionTask + 8from cpdbench.task.Task import TaskType, Task + 9import cpdbench.utils.BenchConfig as BenchConfig +10from cpdbench.utils import Logger +11from cpdbench.utils.Utils import get_name_of_function +12from functools import partial +13 +14 +15class TaskFactory: +16 """Abstract factory for creating task objects""" +17 +18 def __init__(self): +19 self._user_config = BenchConfig.get_user_config() +20 self._logger = Logger.get_application_logger() +21 self._task_counter = 0 +22 +23 def create_task_from_function(self, function: Callable, task_type: TaskType) -> Task: +24 """Creates one task for an unparametrized function. +25 :param function: the function to be executed as task +26 :param task_type: the type of the task to be created +27 :return: the constructed task object +28 """ +29 return self._generate_task_object(function, {}, task_type) +30 +31 def create_tasks_with_parameters(self, function: Callable, task_type: TaskType) -> list[Task]: +32 """Creates correct task objects based on the given task type and the needed parameters defined in the user +33 config. Because of this, this method can potentially output multiple tasks with the same function +34 but different parameters. +35 :param function: the function to be executed as task +36 :param task_type: the type of the task to be created +37 :return: the constructed task objects +38 """ +39 all_params = [param.name for param in inspect.signature(function).parameters.values() if param.kind == +40 param.KEYWORD_ONLY] +41 try: +42 global_params = [param for param in all_params if self._user_config.check_if_global_param(param)] +43 except Exception as e: +44 if "Parameter not found" in str(e): +45 raise UserParameterDoesNotExistException(str(e).split()[-1], get_name_of_function(function)) +46 +47 if all_params is None or len(all_params) == 0: +48 # Easy case: no parameter +49 task = self._generate_task_object(function,{}, task_type) +50 self._logger.info(f"Created task {task.get_task_name()}") +51 self._task_counter += 1 +52 return [task] +53 global_params.sort() +54 all_params.sort() +55 if global_params == all_params: +56 # Easy case: only global params +57 param_values = [{}] +58 else: +59 param_values = [{} for _ in range(self._user_config.get_number_of_executions(task_type))] +60 if len(param_values) == 0: +61 param_values = [{}] +62 +63 for param in all_params: +64 try: +65 vals = self._user_config.get_user_param(param, task_type) +66 except Exception as e: +67 if str(e) == "Parameter not found": +68 raise UserParameterDoesNotExistException(param, get_name_of_function(function)) +69 else: +70 raise e +71 else: +72 for i in range(len(param_values)): +73 if param in global_params: +74 param_values[i].update({param: vals[0]}) # global param # TODO: was wenn param wo fehlt? +75 else: +76 param_values[i].update({param: vals[i]}) # execution param +77 +78 tasks = [] +79 for param_dict in param_values: +80 function_with_params = partial(function, **param_dict) +81 task = self._generate_task_object(function_with_params, param_dict, task_type) +82 self._task_counter += 1 +83 self._logger.info(f"Created task {task.get_task_name()} with following parameters: {str(param_dict)}") +84 tasks.append(task) +85 return tasks +86 +87 def _generate_task_object(self, function: Callable, param_dict: dict, task_type: TaskType): +88 if task_type == TaskType.DATASET_FETCH: +89 return DatasetFetchTask(function, self._task_counter, param_dict) +90 elif task_type == TaskType.ALGORITHM_EXECUTION: +91 return AlgorithmExecutionTask(function, self._task_counter, param_dict) +92 elif task_type == TaskType.METRIC_EXECUTION: +93 return MetricExecutionTask(function, self._task_counter, param_dict) +
16class TaskFactory: +17 """Abstract factory for creating task objects""" +18 +19 def __init__(self): +20 self._user_config = BenchConfig.get_user_config() +21 self._logger = Logger.get_application_logger() +22 self._task_counter = 0 +23 +24 def create_task_from_function(self, function: Callable, task_type: TaskType) -> Task: +25 """Creates one task for an unparametrized function. +26 :param function: the function to be executed as task +27 :param task_type: the type of the task to be created +28 :return: the constructed task object +29 """ +30 return self._generate_task_object(function, {}, task_type) +31 +32 def create_tasks_with_parameters(self, function: Callable, task_type: TaskType) -> list[Task]: +33 """Creates correct task objects based on the given task type and the needed parameters defined in the user +34 config. Because of this, this method can potentially output multiple tasks with the same function +35 but different parameters. +36 :param function: the function to be executed as task +37 :param task_type: the type of the task to be created +38 :return: the constructed task objects +39 """ +40 all_params = [param.name for param in inspect.signature(function).parameters.values() if param.kind == +41 param.KEYWORD_ONLY] +42 try: +43 global_params = [param for param in all_params if self._user_config.check_if_global_param(param)] +44 except Exception as e: +45 if "Parameter not found" in str(e): +46 raise UserParameterDoesNotExistException(str(e).split()[-1], get_name_of_function(function)) +47 +48 if all_params is None or len(all_params) == 0: +49 # Easy case: no parameter +50 task = self._generate_task_object(function,{}, task_type) +51 self._logger.info(f"Created task {task.get_task_name()}") +52 self._task_counter += 1 +53 return [task] +54 global_params.sort() +55 all_params.sort() +56 if global_params == all_params: +57 # Easy case: only global params +58 param_values = [{}] +59 else: +60 param_values = [{} for _ in range(self._user_config.get_number_of_executions(task_type))] +61 if len(param_values) == 0: +62 param_values = [{}] +63 +64 for param in all_params: +65 try: +66 vals = self._user_config.get_user_param(param, task_type) +67 except Exception as e: +68 if str(e) == "Parameter not found": +69 raise UserParameterDoesNotExistException(param, get_name_of_function(function)) +70 else: +71 raise e +72 else: +73 for i in range(len(param_values)): +74 if param in global_params: +75 param_values[i].update({param: vals[0]}) # global param # TODO: was wenn param wo fehlt? +76 else: +77 param_values[i].update({param: vals[i]}) # execution param +78 +79 tasks = [] +80 for param_dict in param_values: +81 function_with_params = partial(function, **param_dict) +82 task = self._generate_task_object(function_with_params, param_dict, task_type) +83 self._task_counter += 1 +84 self._logger.info(f"Created task {task.get_task_name()} with following parameters: {str(param_dict)}") +85 tasks.append(task) +86 return tasks +87 +88 def _generate_task_object(self, function: Callable, param_dict: dict, task_type: TaskType): +89 if task_type == TaskType.DATASET_FETCH: +90 return DatasetFetchTask(function, self._task_counter, param_dict) +91 elif task_type == TaskType.ALGORITHM_EXECUTION: +92 return AlgorithmExecutionTask(function, self._task_counter, param_dict) +93 elif task_type == TaskType.METRIC_EXECUTION: +94 return MetricExecutionTask(function, self._task_counter, param_dict) +
Abstract factory for creating task objects
+24 def create_task_from_function(self, function: Callable, task_type: TaskType) -> Task: +25 """Creates one task for an unparametrized function. +26 :param function: the function to be executed as task +27 :param task_type: the type of the task to be created +28 :return: the constructed task object +29 """ +30 return self._generate_task_object(function, {}, task_type) +
Creates one task for an unparametrized function.
+ +++the constructed task object
+
32 def create_tasks_with_parameters(self, function: Callable, task_type: TaskType) -> list[Task]: +33 """Creates correct task objects based on the given task type and the needed parameters defined in the user +34 config. Because of this, this method can potentially output multiple tasks with the same function +35 but different parameters. +36 :param function: the function to be executed as task +37 :param task_type: the type of the task to be created +38 :return: the constructed task objects +39 """ +40 all_params = [param.name for param in inspect.signature(function).parameters.values() if param.kind == +41 param.KEYWORD_ONLY] +42 try: +43 global_params = [param for param in all_params if self._user_config.check_if_global_param(param)] +44 except Exception as e: +45 if "Parameter not found" in str(e): +46 raise UserParameterDoesNotExistException(str(e).split()[-1], get_name_of_function(function)) +47 +48 if all_params is None or len(all_params) == 0: +49 # Easy case: no parameter +50 task = self._generate_task_object(function,{}, task_type) +51 self._logger.info(f"Created task {task.get_task_name()}") +52 self._task_counter += 1 +53 return [task] +54 global_params.sort() +55 all_params.sort() +56 if global_params == all_params: +57 # Easy case: only global params +58 param_values = [{}] +59 else: +60 param_values = [{} for _ in range(self._user_config.get_number_of_executions(task_type))] +61 if len(param_values) == 0: +62 param_values = [{}] +63 +64 for param in all_params: +65 try: +66 vals = self._user_config.get_user_param(param, task_type) +67 except Exception as e: +68 if str(e) == "Parameter not found": +69 raise UserParameterDoesNotExistException(param, get_name_of_function(function)) +70 else: +71 raise e +72 else: +73 for i in range(len(param_values)): +74 if param in global_params: +75 param_values[i].update({param: vals[0]}) # global param # TODO: was wenn param wo fehlt? +76 else: +77 param_values[i].update({param: vals[i]}) # execution param +78 +79 tasks = [] +80 for param_dict in param_values: +81 function_with_params = partial(function, **param_dict) +82 task = self._generate_task_object(function_with_params, param_dict, task_type) +83 self._task_counter += 1 +84 self._logger.info(f"Created task {task.get_task_name()} with following parameters: {str(param_dict)}") +85 tasks.append(task) +86 return tasks +
Creates correct task objects based on the given task type and the needed parameters defined in the user +config. Because of this, this method can potentially output multiple tasks with the same function +but different parameters.
+ +++the constructed task objects
+
A package containing different utility classes, which are used everywhere in the framework. +Especially logging and configuration classes.
+The global configuration Singleton module. +Contains all configurable parameters for the bench and functions +to read a given config.yml file.
+ +To be used correctly the function load_config(config_file) has to be called first. +After this the other functions can be used.
+1""" + 2The global configuration Singleton module. + 3Contains all configurable parameters for the bench and functions + 4to read a given config.yml file. + 5 + 6To be used correctly the function load_config(config_file) has to be called first. + 7After this the other functions can be used. + 8""" + 9 + 10import yaml + 11import logging + 12 + 13from cpdbench.exception.ConfigurationException import ConfigurationFileNotFoundException, ConfigurationException + 14from cpdbench.utils import Logger + 15from cpdbench.utils.UserConfig import UserConfig + 16 + 17_complete_config = None + 18 + 19# LOGGING + 20logging_file_name: str = 'cpdbench-log.txt' + 21logging_level: int = logging.INFO + 22logging_console_level: int = logging.ERROR + 23 + 24# MULTIPROCESSING + 25multiprocessing_enabled = True + 26 + 27# RESULT + 28result_file_name: str = 'cpdbench-result.json' + 29 + 30# USER PARAMETERS + 31_user_config = None + 32 + 33_config_error_list = [] + 34 + 35 + 36def get_user_config() -> UserConfig: + 37 """Returns the UserConfig object if the BenchConfig was already initialized. + 38 :return the UserConfig object + 39 """ + 40 return _user_config + 41 + 42 + 43def get_complete_config() -> dict: + 44 """Returns the complete bench configuration including the user config as python dict. + 45 :return the config as dict + 46 """ + 47 return { + 48 'logging': { + 49 'logging_file_name': logging_file_name, + 50 'logging_level': logging_level, + 51 'logging_console_level': logging_console_level + 52 }, + 53 'multiprocessing': { + 54 'multiprocessing_enabled': multiprocessing_enabled + 55 }, + 56 'result': { + 57 'result_file_name': result_file_name + 58 }, + 59 'user_config': _user_config.get_param_dict() + 60 } + 61 + 62 + 63def load_config(config_file='config.yml') -> bool: + 64 """Initializes the BenchConfig object with the given config.yml file. + 65 If the config_file param is None or the file does not exist, the bench will use the default parameters and this + 66 function returns false. + 67 :param config_file: The path to the config file + 68 :return: True if the config could be loaded correctly, false otherwise. + 69 """ + 70 global _complete_config + 71 global _user_config + 72 if config_file is None: + 73 _user_config = UserConfig() + 74 _throw_config_errors() + 75 return False + 76 _complete_config = _load_config_from_file(config_file) + 77 if _complete_config is None: + 78 _user_config = UserConfig() + 79 _throw_config_errors() + 80 return False + 81 + 82 # logging + 83 _load_logging_config(_complete_config.get('logging')) + 84 + 85 # multiprocessing enabled + 86 global multiprocessing_enabled + 87 multiprocessing_enabled = False if str(_complete_config.get('multiprocessing')).upper() == 'FALSE' else True + 88 + 89 # result + 90 global result_file_name + 91 result = _complete_config.get('result') + 92 if result is not None: + 93 res_filename = result.get('filename') + 94 if res_filename is not None: + 95 result_file_name = res_filename + 96 + 97 # user variables + 98 _user_config = UserConfig(_complete_config.get('user')) + 99 _user_config.validate_user_config() +100 +101 _throw_config_errors() +102 +103 return True +104 +105 +106def _load_logging_config(logging_config: dict) -> None: +107 if logging_config is None: +108 return +109 # filename +110 global logging_file_name +111 filename = logging_config.get('filename') +112 if filename is not None: +113 logging_file_name = filename +114 +115 # log-level +116 global logging_level +117 logging_level = _get_log_level(logging_config, 'log-level') +118 +119 # log-level console +120 global logging_console_level +121 logging_console_level = _get_log_level(logging_config, 'log-level-console') +122 +123 +124def _get_log_level(config, param_name): +125 if config.get(param_name) is None: +126 return logging.INFO +127 if config[param_name].upper() == 'DEBUG': +128 return logging.DEBUG +129 elif config[param_name].upper() == 'INFO': +130 return logging.INFO +131 elif config[param_name].upper() == 'WARNING' or config[param_name].upper() == "WARN": +132 return logging.WARNING +133 elif config[param_name].upper() == 'ERROR': +134 return logging.ERROR +135 elif config[param_name].upper() == 'CRITICAL': +136 return logging.CRITICAL +137 else: +138 _add_config_error(ConfigurationException(param_name)) +139 return logging.INFO +140 +141 +142def _load_config_from_file(config_file: str): +143 try: +144 with open(config_file, 'r') as config_file_stream: +145 yaml_config = yaml.safe_load(config_file_stream) +146 except OSError: +147 _add_config_error(ConfigurationFileNotFoundException(config_file)) +148 return None +149 else: +150 return yaml_config +151 +152 +153def _add_config_error(exc: Exception) -> None: +154 _config_error_list.append(exc) +155 +156 +157def _throw_config_errors() -> None: +158 logger = Logger.get_application_logger() +159 for exc in _config_error_list: +160 logger.warning(exc) +
37def get_user_config() -> UserConfig: +38 """Returns the UserConfig object if the BenchConfig was already initialized. +39 :return the UserConfig object +40 """ +41 return _user_config +
Returns the UserConfig object if the BenchConfig was already initialized. +:return the UserConfig object
+44def get_complete_config() -> dict: +45 """Returns the complete bench configuration including the user config as python dict. +46 :return the config as dict +47 """ +48 return { +49 'logging': { +50 'logging_file_name': logging_file_name, +51 'logging_level': logging_level, +52 'logging_console_level': logging_console_level +53 }, +54 'multiprocessing': { +55 'multiprocessing_enabled': multiprocessing_enabled +56 }, +57 'result': { +58 'result_file_name': result_file_name +59 }, +60 'user_config': _user_config.get_param_dict() +61 } +
Returns the complete bench configuration including the user config as python dict. +:return the config as dict
+64def load_config(config_file='config.yml') -> bool: + 65 """Initializes the BenchConfig object with the given config.yml file. + 66 If the config_file param is None or the file does not exist, the bench will use the default parameters and this + 67 function returns false. + 68 :param config_file: The path to the config file + 69 :return: True if the config could be loaded correctly, false otherwise. + 70 """ + 71 global _complete_config + 72 global _user_config + 73 if config_file is None: + 74 _user_config = UserConfig() + 75 _throw_config_errors() + 76 return False + 77 _complete_config = _load_config_from_file(config_file) + 78 if _complete_config is None: + 79 _user_config = UserConfig() + 80 _throw_config_errors() + 81 return False + 82 + 83 # logging + 84 _load_logging_config(_complete_config.get('logging')) + 85 + 86 # multiprocessing enabled + 87 global multiprocessing_enabled + 88 multiprocessing_enabled = False if str(_complete_config.get('multiprocessing')).upper() == 'FALSE' else True + 89 + 90 # result + 91 global result_file_name + 92 result = _complete_config.get('result') + 93 if result is not None: + 94 res_filename = result.get('filename') + 95 if res_filename is not None: + 96 result_file_name = res_filename + 97 + 98 # user variables + 99 _user_config = UserConfig(_complete_config.get('user')) +100 _user_config.validate_user_config() +101 +102 _throw_config_errors() +103 +104 return True +
Initializes the BenchConfig object with the given config.yml file. +If the config_file param is None or the file does not exist, the bench will use the default parameters and this +function returns false.
+ +++True if the config could be loaded correctly, false otherwise.
+
1# Was wird geloggt? + 2# DEBUG + 3# alle Schritte => Methoden-Signaturen, Erstellung von Tasks, Beginnen/Ende von Validierungen, Task-Erstellungen, + 4# INFO + 5# Start und Ende von Verarbeitungen => Testrun, Task-Ausführungen + Performance + 6# WARNING + 7# (evtl. unterdrückte Validation-Fehler)? + 8# ERROR + 9# Exceptions in Tasks, Validation-Fehler +10# CRITICAL +11# Exceptions, die die Testbench beendet haben +12 +13 +14# Logging-Mechanismus +15# - nicht auf root => https://docs.python.org/3/howto/logging.html#logging-levels +16# - z.B. tcpd-bench:testrun-name:dataset-fetch +17# - In File => Exceptions/Crits auf Konsole +18 +19# STDOUT + cpdbench-result.json => Result-JSON +20# cpdbench-log.txt => alle Log-Messages +21# STDERR => ERROR + CRITICAL +22 +23import logging +24from cpdbench.utils import BenchConfig +25 +26_app_logger = None +27 +28 +29def init_logger(): +30 global _app_logger +31 _app_logger = logging.Logger('cpdbench') +32 _app_logger.setLevel(logging.DEBUG) +33 console_handler = logging.StreamHandler() +34 general_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') +35 console_handler.setFormatter(general_formatter) +36 console_handler.setLevel(BenchConfig.logging_console_level) +37 _app_logger.addHandler(console_handler) +38 +39 # open('cpdbench-log.txt', 'w').close() +40 file_handler = logging.FileHandler(BenchConfig.logging_file_name, 'w') +41 file_handler.setFormatter(general_formatter) +42 file_handler.setLevel(BenchConfig.logging_level) +43 _app_logger.addHandler(file_handler) +44 return _app_logger +45 +46 +47def get_application_logger() -> logging.Logger: +48 if _app_logger is None: +49 return init_logger() +50 return _app_logger +
30def init_logger(): +31 global _app_logger +32 _app_logger = logging.Logger('cpdbench') +33 _app_logger.setLevel(logging.DEBUG) +34 console_handler = logging.StreamHandler() +35 general_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') +36 console_handler.setFormatter(general_formatter) +37 console_handler.setLevel(BenchConfig.logging_console_level) +38 _app_logger.addHandler(console_handler) +39 +40 # open('cpdbench-log.txt', 'w').close() +41 file_handler = logging.FileHandler(BenchConfig.logging_file_name, 'w') +42 file_handler.setFormatter(general_formatter) +43 file_handler.setLevel(BenchConfig.logging_level) +44 _app_logger.addHandler(file_handler) +45 return _app_logger +
1from cpdbench.task.Task import TaskType + 2 + 3 + 4def _get_path_to_execution_array(task_type: TaskType) -> str: + 5 """Returns the path in the user config dict to the needed execution variables depending on the task type + 6 :param task_type: the task type for which the path is needed + 7 :return: the path in the user config + 8 """ + 9 if task_type == TaskType.DATASET_FETCH: + 10 return "dataset-executions" + 11 elif task_type == TaskType.ALGORITHM_EXECUTION: + 12 return "algorithm-executions" + 13 else: + 14 return "metric-executions" + 15 + 16 + 17class UserConfig: + 18 """This class represents the part of the global config file which contains all user variables. + 19 There are two types of user parameters/variables in this testbench: + 20 - global variables: variables which can be used in any task, and can only be defined once + 21 - execution variables: specific variables for each task type, for which multiple instances/different values given + 22 as list can exist. In this case, any task using these are executed multiple times depending on the amount of + 23 given instances. A use case for this is executing the same algorithm but with different parameters. + 24 """ + 25 + 26 def __init__(self, user_params=None): + 27 """Constructor for the UserConfig class + 28 :param user_params: the user params as dict extracted from the config file + 29 """ + 30 if user_params is None: + 31 user_params = {} + 32 self._user_param_dict = user_params + 33 + 34 def get_number_of_executions(self, tasks_type: TaskType) -> int: + 35 """Returns the needed number of executions of each task for the given type depending on the amount of + 36 parameter sets + 37 :param tasks_type: the task type for which the number should be returned + 38 :return: the number of executions + 39 """ + 40 if self._user_param_dict == {}: + 41 return 1 + 42 execution_yaml = self._user_param_dict.get(_get_path_to_execution_array(tasks_type)) + 43 if execution_yaml is None: + 44 return 1 + 45 return len(execution_yaml) + 46 + 47 def get_user_param(self, param_name: str, task_type: TaskType) -> list: + 48 """Returns the values of the given user parameter name. + 49 Returns a list because for execution variables multiple instances (for multiple runs) can be defined. + 50 Throws an exception if the parameter is not defined. + 51 :param param_name: the name of the user parameter + 52 :param task_type: the task type if the parameter is an execution variable. + 53 If it is a global variable, this parameter is not used. + 54 :return: a list of all possible values for the requested parameter + 55 """ + 56 global_param = self._user_param_dict.get(param_name) + 57 if global_param is not None: + 58 return [global_param] + 59 else: + 60 dict_string = _get_path_to_execution_array(task_type) + 61 try: + 62 exec_list = self._user_param_dict[dict_string] + 63 except KeyError: + 64 raise Exception("Parameter not found") + 65 if exec_list is None: + 66 raise Exception("Parameter not found") + 67 try: + 68 result = [execution_dict[param_name] for execution_dict in exec_list] + 69 except KeyError: + 70 raise Exception("Parameter not found") + 71 else: + 72 if result is None or len(result) == 0: + 73 raise Exception("Parameter not found") + 74 return result + 75 + 76 def check_if_global_param(self, param_name: str) -> bool: + 77 """Checks if the given parameter is a global one or an execution parameter. + 78 :param param_name: the name of the to be checked parameter + 79 :return: True if the parameter is a global one. False otherwise. + 80 """ + 81 is_global_param = None + 82 global_param = self._user_param_dict.get(param_name) + 83 if global_param is not None: + 84 is_global_param = True + 85 for i in ["dataset-executions", "algorithm-executions", "metric-executions"]: + 86 part_dict = self._user_param_dict.get(i) + 87 if part_dict is None or part_dict[0] is None: + 88 continue + 89 user_param = part_dict[0].get(param_name) + 90 if user_param is not None: + 91 if is_global_param is True: + 92 raise Exception("Parameter both global and execution") + 93 else: + 94 return False + 95 if is_global_param is None: + 96 raise Exception("Parameter not found: " + param_name) + 97 else: + 98 return is_global_param + 99 +100 def get_param_dict(self) -> dict: +101 """Returns all user params as dict for logging purposes. +102 :return: the user param dict""" +103 return self._user_param_dict +104 +105 def validate_user_config(self) -> None: +106 """Validates the user config for common errors. +107 This method returns nothing if the validation is successful, and throws errors +108 if something is wrong with the config, as the bench cannot continue with consistency +109 errors in the config. +110 """ +111 # execution params are declared correctly +112 for i in ["dataset-executions", "algorithm-executions", "metric-executions"]: +113 exec_dict = self._user_param_dict.get(i) +114 if exec_dict is None: +115 continue +116 if type(exec_dict) is not list: +117 raise Exception("execution params not declared correctly") +118 for j in exec_dict: +119 if type(j) is not dict: +120 raise Exception("execution params not declared correctly") +121 +122 # execution param is given for all configurations +123 for i in ["dataset-executions", "algorithm-executions", "metric-executions"]: +124 part_dict = self._user_param_dict.get(i) +125 if part_dict is None: +126 continue +127 exec_params = [param for param in part_dict[0]] +128 for j in range(1, len(part_dict)): +129 for par in exec_params: +130 if part_dict[j].get(par) is None: +131 raise Exception("Parameter not found in all configurations") +132 +133 params = self._get_all_params() +134 for param in params: +135 # parameters are defined as both global and execution +136 is_global_param = None +137 global_param = self._user_param_dict.get(param) +138 if global_param is not None: +139 is_global_param = True +140 for i in ["dataset-executions", "algorithm-executions", "metric-executions"]: +141 part_dict = self._user_param_dict.get(i) +142 if part_dict is None: +143 continue +144 user_param = part_dict[0].get(param) +145 if user_param is not None: +146 if is_global_param is True: +147 raise Exception("Parameter both global and execution") +148 +149 def _get_all_params(self) -> set: +150 params = [param for param in self._user_param_dict +151 if param not in ["dataset-executions", "algorithm-executions", "metric-executions"]] +152 for i in ["dataset-executions", "algorithm-executions", "metric-executions"]: +153 exec_dict = self._user_param_dict.get(i) +154 if exec_dict is None: +155 continue +156 user_params = [param for param in exec_dict[0]] +157 params = params + user_params +158 return set(params) +
18class UserConfig: + 19 """This class represents the part of the global config file which contains all user variables. + 20 There are two types of user parameters/variables in this testbench: + 21 - global variables: variables which can be used in any task, and can only be defined once + 22 - execution variables: specific variables for each task type, for which multiple instances/different values given + 23 as list can exist. In this case, any task using these are executed multiple times depending on the amount of + 24 given instances. A use case for this is executing the same algorithm but with different parameters. + 25 """ + 26 + 27 def __init__(self, user_params=None): + 28 """Constructor for the UserConfig class + 29 :param user_params: the user params as dict extracted from the config file + 30 """ + 31 if user_params is None: + 32 user_params = {} + 33 self._user_param_dict = user_params + 34 + 35 def get_number_of_executions(self, tasks_type: TaskType) -> int: + 36 """Returns the needed number of executions of each task for the given type depending on the amount of + 37 parameter sets + 38 :param tasks_type: the task type for which the number should be returned + 39 :return: the number of executions + 40 """ + 41 if self._user_param_dict == {}: + 42 return 1 + 43 execution_yaml = self._user_param_dict.get(_get_path_to_execution_array(tasks_type)) + 44 if execution_yaml is None: + 45 return 1 + 46 return len(execution_yaml) + 47 + 48 def get_user_param(self, param_name: str, task_type: TaskType) -> list: + 49 """Returns the values of the given user parameter name. + 50 Returns a list because for execution variables multiple instances (for multiple runs) can be defined. + 51 Throws an exception if the parameter is not defined. + 52 :param param_name: the name of the user parameter + 53 :param task_type: the task type if the parameter is an execution variable. + 54 If it is a global variable, this parameter is not used. + 55 :return: a list of all possible values for the requested parameter + 56 """ + 57 global_param = self._user_param_dict.get(param_name) + 58 if global_param is not None: + 59 return [global_param] + 60 else: + 61 dict_string = _get_path_to_execution_array(task_type) + 62 try: + 63 exec_list = self._user_param_dict[dict_string] + 64 except KeyError: + 65 raise Exception("Parameter not found") + 66 if exec_list is None: + 67 raise Exception("Parameter not found") + 68 try: + 69 result = [execution_dict[param_name] for execution_dict in exec_list] + 70 except KeyError: + 71 raise Exception("Parameter not found") + 72 else: + 73 if result is None or len(result) == 0: + 74 raise Exception("Parameter not found") + 75 return result + 76 + 77 def check_if_global_param(self, param_name: str) -> bool: + 78 """Checks if the given parameter is a global one or an execution parameter. + 79 :param param_name: the name of the to be checked parameter + 80 :return: True if the parameter is a global one. False otherwise. + 81 """ + 82 is_global_param = None + 83 global_param = self._user_param_dict.get(param_name) + 84 if global_param is not None: + 85 is_global_param = True + 86 for i in ["dataset-executions", "algorithm-executions", "metric-executions"]: + 87 part_dict = self._user_param_dict.get(i) + 88 if part_dict is None or part_dict[0] is None: + 89 continue + 90 user_param = part_dict[0].get(param_name) + 91 if user_param is not None: + 92 if is_global_param is True: + 93 raise Exception("Parameter both global and execution") + 94 else: + 95 return False + 96 if is_global_param is None: + 97 raise Exception("Parameter not found: " + param_name) + 98 else: + 99 return is_global_param +100 +101 def get_param_dict(self) -> dict: +102 """Returns all user params as dict for logging purposes. +103 :return: the user param dict""" +104 return self._user_param_dict +105 +106 def validate_user_config(self) -> None: +107 """Validates the user config for common errors. +108 This method returns nothing if the validation is successful, and throws errors +109 if something is wrong with the config, as the bench cannot continue with consistency +110 errors in the config. +111 """ +112 # execution params are declared correctly +113 for i in ["dataset-executions", "algorithm-executions", "metric-executions"]: +114 exec_dict = self._user_param_dict.get(i) +115 if exec_dict is None: +116 continue +117 if type(exec_dict) is not list: +118 raise Exception("execution params not declared correctly") +119 for j in exec_dict: +120 if type(j) is not dict: +121 raise Exception("execution params not declared correctly") +122 +123 # execution param is given for all configurations +124 for i in ["dataset-executions", "algorithm-executions", "metric-executions"]: +125 part_dict = self._user_param_dict.get(i) +126 if part_dict is None: +127 continue +128 exec_params = [param for param in part_dict[0]] +129 for j in range(1, len(part_dict)): +130 for par in exec_params: +131 if part_dict[j].get(par) is None: +132 raise Exception("Parameter not found in all configurations") +133 +134 params = self._get_all_params() +135 for param in params: +136 # parameters are defined as both global and execution +137 is_global_param = None +138 global_param = self._user_param_dict.get(param) +139 if global_param is not None: +140 is_global_param = True +141 for i in ["dataset-executions", "algorithm-executions", "metric-executions"]: +142 part_dict = self._user_param_dict.get(i) +143 if part_dict is None: +144 continue +145 user_param = part_dict[0].get(param) +146 if user_param is not None: +147 if is_global_param is True: +148 raise Exception("Parameter both global and execution") +149 +150 def _get_all_params(self) -> set: +151 params = [param for param in self._user_param_dict +152 if param not in ["dataset-executions", "algorithm-executions", "metric-executions"]] +153 for i in ["dataset-executions", "algorithm-executions", "metric-executions"]: +154 exec_dict = self._user_param_dict.get(i) +155 if exec_dict is None: +156 continue +157 user_params = [param for param in exec_dict[0]] +158 params = params + user_params +159 return set(params) +
This class represents the part of the global config file which contains all user variables. +There are two types of user parameters/variables in this testbench:
+ +27 def __init__(self, user_params=None): +28 """Constructor for the UserConfig class +29 :param user_params: the user params as dict extracted from the config file +30 """ +31 if user_params is None: +32 user_params = {} +33 self._user_param_dict = user_params +
Constructor for the UserConfig class
+ +35 def get_number_of_executions(self, tasks_type: TaskType) -> int: +36 """Returns the needed number of executions of each task for the given type depending on the amount of +37 parameter sets +38 :param tasks_type: the task type for which the number should be returned +39 :return: the number of executions +40 """ +41 if self._user_param_dict == {}: +42 return 1 +43 execution_yaml = self._user_param_dict.get(_get_path_to_execution_array(tasks_type)) +44 if execution_yaml is None: +45 return 1 +46 return len(execution_yaml) +
Returns the needed number of executions of each task for the given type depending on the amount of +parameter sets
+ +++the number of executions
+
48 def get_user_param(self, param_name: str, task_type: TaskType) -> list: +49 """Returns the values of the given user parameter name. +50 Returns a list because for execution variables multiple instances (for multiple runs) can be defined. +51 Throws an exception if the parameter is not defined. +52 :param param_name: the name of the user parameter +53 :param task_type: the task type if the parameter is an execution variable. +54 If it is a global variable, this parameter is not used. +55 :return: a list of all possible values for the requested parameter +56 """ +57 global_param = self._user_param_dict.get(param_name) +58 if global_param is not None: +59 return [global_param] +60 else: +61 dict_string = _get_path_to_execution_array(task_type) +62 try: +63 exec_list = self._user_param_dict[dict_string] +64 except KeyError: +65 raise Exception("Parameter not found") +66 if exec_list is None: +67 raise Exception("Parameter not found") +68 try: +69 result = [execution_dict[param_name] for execution_dict in exec_list] +70 except KeyError: +71 raise Exception("Parameter not found") +72 else: +73 if result is None or len(result) == 0: +74 raise Exception("Parameter not found") +75 return result +
Returns the values of the given user parameter name. +Returns a list because for execution variables multiple instances (for multiple runs) can be defined. +Throws an exception if the parameter is not defined.
+ +++a list of all possible values for the requested parameter
+
77 def check_if_global_param(self, param_name: str) -> bool: +78 """Checks if the given parameter is a global one or an execution parameter. +79 :param param_name: the name of the to be checked parameter +80 :return: True if the parameter is a global one. False otherwise. +81 """ +82 is_global_param = None +83 global_param = self._user_param_dict.get(param_name) +84 if global_param is not None: +85 is_global_param = True +86 for i in ["dataset-executions", "algorithm-executions", "metric-executions"]: +87 part_dict = self._user_param_dict.get(i) +88 if part_dict is None or part_dict[0] is None: +89 continue +90 user_param = part_dict[0].get(param_name) +91 if user_param is not None: +92 if is_global_param is True: +93 raise Exception("Parameter both global and execution") +94 else: +95 return False +96 if is_global_param is None: +97 raise Exception("Parameter not found: " + param_name) +98 else: +99 return is_global_param +
Checks if the given parameter is a global one or an execution parameter.
+ +++True if the parameter is a global one. False otherwise.
+
101 def get_param_dict(self) -> dict: +102 """Returns all user params as dict for logging purposes. +103 :return: the user param dict""" +104 return self._user_param_dict +
Returns all user params as dict for logging purposes.
+ +++the user param dict
+
106 def validate_user_config(self) -> None: +107 """Validates the user config for common errors. +108 This method returns nothing if the validation is successful, and throws errors +109 if something is wrong with the config, as the bench cannot continue with consistency +110 errors in the config. +111 """ +112 # execution params are declared correctly +113 for i in ["dataset-executions", "algorithm-executions", "metric-executions"]: +114 exec_dict = self._user_param_dict.get(i) +115 if exec_dict is None: +116 continue +117 if type(exec_dict) is not list: +118 raise Exception("execution params not declared correctly") +119 for j in exec_dict: +120 if type(j) is not dict: +121 raise Exception("execution params not declared correctly") +122 +123 # execution param is given for all configurations +124 for i in ["dataset-executions", "algorithm-executions", "metric-executions"]: +125 part_dict = self._user_param_dict.get(i) +126 if part_dict is None: +127 continue +128 exec_params = [param for param in part_dict[0]] +129 for j in range(1, len(part_dict)): +130 for par in exec_params: +131 if part_dict[j].get(par) is None: +132 raise Exception("Parameter not found in all configurations") +133 +134 params = self._get_all_params() +135 for param in params: +136 # parameters are defined as both global and execution +137 is_global_param = None +138 global_param = self._user_param_dict.get(param) +139 if global_param is not None: +140 is_global_param = True +141 for i in ["dataset-executions", "algorithm-executions", "metric-executions"]: +142 part_dict = self._user_param_dict.get(i) +143 if part_dict is None: +144 continue +145 user_param = part_dict[0].get(param) +146 if user_param is not None: +147 if is_global_param is True: +148 raise Exception("Parameter both global and execution") +
Validates the user config for common errors. +This method returns nothing if the validation is successful, and throws errors +if something is wrong with the config, as the bench cannot continue with consistency +errors in the config.
+1import inspect + 2from typing import Callable + 3 + 4"""Utils.py module + 5This module contains various utility functions which are needed by multiple objects in the testbench + 6""" + 7 + 8 + 9def get_name_of_function(function_ref: Callable) -> str: +10 """Returns the name of the given function reference/object by using the inspect module +11 :param function_ref: the function reference +12 :return: the name of the function +13 """ +14 name_gen = (attr[1] for attr in inspect.getmembers(function_ref) if attr[0] == "__name__") +15 return next(name_gen) +
10def get_name_of_function(function_ref: Callable) -> str: +11 """Returns the name of the given function reference/object by using the inspect module +12 :param function_ref: the function reference +13 :return: the name of the function +14 """ +15 name_gen = (attr[1] for attr in inspect.getmembers(function_ref) if attr[0] == "__name__") +16 return next(name_gen) +
Returns the name of the given function reference/object by using the inspect module
+ +++the name of the function
+
Main class for accessing the CPDBench functions
\n"}, "cpdbench.CPDBench.CPDBench.start": {"fullname": "cpdbench.CPDBench.CPDBench.start", "modulename": "cpdbench.CPDBench", "qualname": "CPDBench.start", "kind": "function", "doc": "Start the execution of the CDPBench environment
\n\nValidate the given functions for a full bench run. Throws an exception if the validation fails.
\n\nDecorator for dataset functions which create CPDDataset objects
\n", "signature": "(self, function):", "funcdef": "def"}, "cpdbench.CPDBench.CPDBench.algorithm": {"fullname": "cpdbench.CPDBench.CPDBench.algorithm", "modulename": "cpdbench.CPDBench", "qualname": "CPDBench.algorithm", "kind": "function", "doc": "Decorator for algorithm functions which execute changepoint algorithms
\n", "signature": "(self, function):", "funcdef": "def"}, "cpdbench.CPDBench.CPDBench.metric": {"fullname": "cpdbench.CPDBench.CPDBench.metric", "modulename": "cpdbench.CPDBench", "qualname": "CPDBench.metric", "kind": "function", "doc": "Decorator for metric functions which evaluate changepoint results
\n", "signature": "(self, function):", "funcdef": "def"}, "cpdbench.control": {"fullname": "cpdbench.control", "modulename": "cpdbench.control", "kind": "module", "doc": "This package contains all classes responsible for running the main program logic,\nespecially the testbench runs.
\n"}, "cpdbench.control.CPDDatasetResult": {"fullname": "cpdbench.control.CPDDatasetResult", "modulename": "cpdbench.control.CPDDatasetResult", "kind": "module", "doc": "\n"}, "cpdbench.control.CPDDatasetResult.ErrorType": {"fullname": "cpdbench.control.CPDDatasetResult.ErrorType", "modulename": "cpdbench.control.CPDDatasetResult", "qualname": "ErrorType", "kind": "class", "doc": "Enum for all error types which can occur during the CPDBench execution
\n", "bases": "builtins.str, enum.Enum"}, "cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"fullname": "cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR", "modulename": "cpdbench.control.CPDDatasetResult", "qualname": "ErrorType.DATASET_ERROR", "kind": "variable", "doc": "\n", "default_value": "<ErrorType.DATASET_ERROR: 'DATASET_ERROR'>"}, "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"fullname": "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR", "modulename": "cpdbench.control.CPDDatasetResult", "qualname": "ErrorType.ALGORITHM_ERROR", "kind": "variable", "doc": "\n", "default_value": "<ErrorType.ALGORITHM_ERROR: 'ALGORITHM_ERROR'>"}, "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"fullname": "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR", "modulename": "cpdbench.control.CPDDatasetResult", "qualname": "ErrorType.METRIC_ERROR", "kind": "variable", "doc": "\n", "default_value": "<ErrorType.METRIC_ERROR: 'METRIC_ERROR'>"}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"fullname": "cpdbench.control.CPDDatasetResult.CPDDatasetResult", "modulename": "cpdbench.control.CPDDatasetResult", "qualname": "CPDDatasetResult", "kind": "class", "doc": "Container for all results of one single dataset including algorithm and metric results
\n"}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"fullname": "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__", "modulename": "cpdbench.control.CPDDatasetResult", "qualname": "CPDDatasetResult.__init__", "kind": "function", "doc": "Constructs a dataset result with the basic attributes
\n\nAdds the runtime of the dataset task to the result object.\nOnce a runtime was added, the value is immutable.
\n\nAdds an algorithm result with indexes and confidence scores to the result container.
\n\nAdds a metric result of an algorithm/dataset to the result container.
\n\nAdds a thrown error to the result container.
\n\nReturns the result container formatted as dictionary.\n:returns: the complete results with indexes, scores and metric scores of one dataset as dict
\n", "signature": "(self) -> dict:", "funcdef": "def"}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"fullname": "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list", "modulename": "cpdbench.control.CPDDatasetResult", "qualname": "CPDDatasetResult.get_errors_as_list", "kind": "function", "doc": "Returns the list of errors occurred around the dataset.\n:returns: all errors of the dataset as python list
\n", "signature": "(self) -> list:", "funcdef": "def"}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"fullname": "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters", "modulename": "cpdbench.control.CPDDatasetResult", "qualname": "CPDDatasetResult.get_parameters", "kind": "function", "doc": "Returns the parameters of all included tasks as dict.\n:returns: the parameters as python dict
\n", "signature": "(self) -> dict:", "funcdef": "def"}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"fullname": "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes", "modulename": "cpdbench.control.CPDDatasetResult", "qualname": "CPDDatasetResult.get_runtimes", "kind": "function", "doc": "Returns the runtimes of all included tasks as dict.\n:returns: the runtimes as python dict
\n", "signature": "(self) -> dict:", "funcdef": "def"}, "cpdbench.control.CPDFullResult": {"fullname": "cpdbench.control.CPDFullResult", "modulename": "cpdbench.control.CPDFullResult", "kind": "module", "doc": "\n"}, "cpdbench.control.CPDFullResult.CPDFullResult": {"fullname": "cpdbench.control.CPDFullResult.CPDFullResult", "modulename": "cpdbench.control.CPDFullResult", "qualname": "CPDFullResult", "kind": "class", "doc": "Container for a complete run result with all datasets
\n", "bases": "cpdbench.control.CPDResult.CPDResult"}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"fullname": "cpdbench.control.CPDFullResult.CPDFullResult.__init__", "modulename": "cpdbench.control.CPDFullResult", "qualname": "CPDFullResult.__init__", "kind": "function", "doc": "Construct a CPDFullResult object with basic metadata
\n\nAdds a calculated dataset result to the FullResult
\n\nReturns the complete result with all dataset results and metadata as python dict
\n\n\n\n", "signature": "(self) -> dict:", "funcdef": "def"}, "cpdbench.control.CPDResult": {"fullname": "cpdbench.control.CPDResult", "modulename": "cpdbench.control.CPDResult", "kind": "module", "doc": "\n"}, "cpdbench.control.CPDResult.CPDResult": {"fullname": "cpdbench.control.CPDResult.CPDResult", "modulename": "cpdbench.control.CPDResult", "qualname": "CPDResult", "kind": "class", "doc": "the result as python dict
\n
Abstract class for result containers for bench runs
\n", "bases": "abc.ABC"}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"fullname": "cpdbench.control.CPDResult.CPDResult.get_result_as_dict", "modulename": "cpdbench.control.CPDResult", "qualname": "CPDResult.get_result_as_dict", "kind": "function", "doc": "Returns the result of the bench run as python dict
\n", "signature": "(self) -> dict:", "funcdef": "def"}, "cpdbench.control.CPDValidationResult": {"fullname": "cpdbench.control.CPDValidationResult", "modulename": "cpdbench.control.CPDValidationResult", "kind": "module", "doc": "\n"}, "cpdbench.control.CPDValidationResult.CPDValidationResult": {"fullname": "cpdbench.control.CPDValidationResult.CPDValidationResult", "modulename": "cpdbench.control.CPDValidationResult", "qualname": "CPDValidationResult", "kind": "class", "doc": "Container for a validation run result.
\n", "bases": "cpdbench.control.CPDResult.CPDResult"}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"fullname": "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__", "modulename": "cpdbench.control.CPDValidationResult", "qualname": "CPDValidationResult.__init__", "kind": "function", "doc": "Construct a validation result object
\n\nReturn the complete result with all dataset results and metadata as python dict
\n\n\n\n", "signature": "(self) -> dict:", "funcdef": "def"}, "cpdbench.control.DatasetExecutor": {"fullname": "cpdbench.control.DatasetExecutor", "modulename": "cpdbench.control.DatasetExecutor", "kind": "module", "doc": "\n"}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"fullname": "cpdbench.control.DatasetExecutor.DatasetExecutor", "modulename": "cpdbench.control.DatasetExecutor", "qualname": "DatasetExecutor", "kind": "class", "doc": "the result as python dict
\n
Helper class for the TestrunController for the execution of all algorithm and metric tasks\nof one dataset for better structure.\nThis executor runs on subprocesses in multiprocessing mode.
\n"}, "cpdbench.control.DatasetExecutor.DatasetExecutor.__init__": {"fullname": "cpdbench.control.DatasetExecutor.DatasetExecutor.__init__", "modulename": "cpdbench.control.DatasetExecutor", "qualname": "DatasetExecutor.__init__", "kind": "function", "doc": "\n", "signature": "(dataset_task, algorithm_tasks, metric_tasks, logger)"}, "cpdbench.control.DatasetExecutor.DatasetExecutor.logger": {"fullname": "cpdbench.control.DatasetExecutor.DatasetExecutor.logger", "modulename": "cpdbench.control.DatasetExecutor", "qualname": "DatasetExecutor.logger", "kind": "variable", "doc": "\n"}, "cpdbench.control.DatasetExecutor.DatasetExecutor.execute": {"fullname": "cpdbench.control.DatasetExecutor.DatasetExecutor.execute", "modulename": "cpdbench.control.DatasetExecutor", "qualname": "DatasetExecutor.execute", "kind": "function", "doc": "Executes the entered algorithm and metric tasks.
\n", "signature": "(self):", "funcdef": "def"}, "cpdbench.control.ExecutionController": {"fullname": "cpdbench.control.ExecutionController", "modulename": "cpdbench.control.ExecutionController", "kind": "module", "doc": "\n"}, "cpdbench.control.ExecutionController.ExecutionController": {"fullname": "cpdbench.control.ExecutionController.ExecutionController", "modulename": "cpdbench.control.ExecutionController", "qualname": "ExecutionController", "kind": "class", "doc": "Abstract base class for testbench run configurations.\nEach subclass has to give an execute_run() implementation with the actual run logic.
\n", "bases": "abc.ABC"}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"fullname": "cpdbench.control.ExecutionController.ExecutionController.execute_run", "modulename": "cpdbench.control.ExecutionController", "qualname": "ExecutionController.execute_run", "kind": "function", "doc": "Executes the run implemented by this class.
\n\n\n\n", "signature": "(self, methods: dict) -> cpdbench.control.CPDResult.CPDResult:", "funcdef": "def"}, "cpdbench.control.TestbenchController": {"fullname": "cpdbench.control.TestbenchController", "modulename": "cpdbench.control.TestbenchController", "kind": "module", "doc": "\n"}, "cpdbench.control.TestbenchController.TestrunType": {"fullname": "cpdbench.control.TestbenchController.TestrunType", "modulename": "cpdbench.control.TestbenchController", "qualname": "TestrunType", "kind": "class", "doc": "A result object which can be handed to the user
\n
Types of predefined run configurations
\n", "bases": "enum.Enum"}, "cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"fullname": "cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN", "modulename": "cpdbench.control.TestbenchController", "qualname": "TestrunType.NORMAL_RUN", "kind": "variable", "doc": "\n", "default_value": "<TestrunType.NORMAL_RUN: (1,)>"}, "cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"fullname": "cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN", "modulename": "cpdbench.control.TestbenchController", "qualname": "TestrunType.VALIDATION_RUN", "kind": "variable", "doc": "\n", "default_value": "<TestrunType.VALIDATION_RUN: 2>"}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"fullname": "cpdbench.control.TestbenchController.ExtendedEncoder", "modulename": "cpdbench.control.TestbenchController", "qualname": "ExtendedEncoder", "kind": "class", "doc": "Extensible JSON http://json.org encoder for Python data structures.
\n\nSupports the following objects and types by default:
\n\n+-------------------+---------------+\n| Python | JSON |\n+===================+===============+\n| dict | object |\n+-------------------+---------------+\n| list, tuple | array |\n+-------------------+---------------+\n| str | string |\n+-------------------+---------------+\n| int, float | number |\n+-------------------+---------------+\n| True | true |\n+-------------------+---------------+\n| False | false |\n+-------------------+---------------+\n| None | null |\n+-------------------+---------------+
\n\nTo extend this to recognize other objects, subclass and implement a\n.default() method with another method that returns a serializable\nobject for o if possible, otherwise it should call the superclass\nimplementation (to raise TypeError).
Implement this method in a subclass such that it returns\na serializable object for o, or calls the base implementation\n(to raise a TypeError).
For example, to support arbitrary iterators, you could\nimplement default like this::
\n\ndef default(self, o):\n try:\n iterable = iter(o)\n except TypeError:\n pass\n else:\n return list(iterable)\n # Let the base class default method raise the TypeError\n return JSONEncoder.default(self, o)\nMain controller for starting different types of test runs.\nThis is the basic class which is executed after initialization of the framework.\nThis controller then calls an ExecutionController implementation, which contains\nthe actual logic of a run.
\n"}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"fullname": "cpdbench.control.TestbenchController.TestbenchController.execute_testrun", "modulename": "cpdbench.control.TestbenchController", "qualname": "TestbenchController.execute_testrun", "kind": "function", "doc": "Prepares and runs the required testrun
\n\nAn ExecutionController implementation for the standard run configuration.\nAs described in the paper, all given datasets, algorithms and metrics are\ncompletely executed and all results are stored in a CPDFullResult.
\n", "bases": "cpdbench.control.ExecutionController.ExecutionController"}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"fullname": "cpdbench.control.TestrunController.TestrunController.execute_run", "modulename": "cpdbench.control.TestrunController", "qualname": "TestrunController.execute_run", "kind": "function", "doc": "Executes the run implemented by this class.
\n\n\n\n", "signature": "(self, methods: dict) -> cpdbench.control.CPDResult.CPDResult:", "funcdef": "def"}, "cpdbench.control.ValidationRunController": {"fullname": "cpdbench.control.ValidationRunController", "modulename": "cpdbench.control.ValidationRunController", "kind": "module", "doc": "\n"}, "cpdbench.control.ValidationRunController.ValidationRunController": {"fullname": "cpdbench.control.ValidationRunController.ValidationRunController", "modulename": "cpdbench.control.ValidationRunController", "qualname": "ValidationRunController", "kind": "class", "doc": "A result object which can be handed to the user
\n
A run configuration for validation runs.\nThese runs only execute algorithms with a (user defined) subset of the datasets,\nand do not return the complete result sets.
\n", "bases": "cpdbench.control.ExecutionController.ExecutionController"}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"fullname": "cpdbench.control.ValidationRunController.ValidationRunController.execute_run", "modulename": "cpdbench.control.ValidationRunController", "qualname": "ValidationRunController.execute_run", "kind": "function", "doc": "Executes the run implemented by this class.
\n\n\n\n", "signature": "(self, methods: dict) -> cpdbench.control.CPDResult.CPDResult:", "funcdef": "def"}, "cpdbench.dataset": {"fullname": "cpdbench.dataset", "modulename": "cpdbench.dataset", "kind": "module", "doc": "A result object which can be handed to the user
\n
This package contains all classes representing CPD datasets.\nThis includes the abstract base class CPDDataset and two implementations
\n"}, "cpdbench.dataset.CPD2DFromFileDataset": {"fullname": "cpdbench.dataset.CPD2DFromFileDataset", "modulename": "cpdbench.dataset.CPD2DFromFileDataset", "kind": "module", "doc": "\n"}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"fullname": "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset", "modulename": "cpdbench.dataset.CPD2DFromFileDataset", "qualname": "CPD2DFromFileDataset", "kind": "class", "doc": "Implementation of CPDDataset where the data source is large numpy array saved as file via memmap.\nWith this implementation the framework can use very large datasets which are not completely loaded\ninto the main memory. Instead numpy will lazy load all needed data points.
\n", "bases": "cpdbench.dataset.CPDDataset.CPDDataset"}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"fullname": "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__", "modulename": "cpdbench.dataset.CPD2DFromFileDataset", "qualname": "CPD2DFromFileDataset.__init__", "kind": "function", "doc": "Constructor
\n\nInitialization method to prepare the dataset.\nExamples: Open a file, open a db connection etc.
\n", "signature": "(self) -> None:", "funcdef": "def"}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"fullname": "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal", "modulename": "cpdbench.dataset.CPD2DFromFileDataset", "qualname": "CPD2DFromFileDataset.get_signal", "kind": "function", "doc": "Returns the timeseries as numpy array.
\n\n\n\n", "signature": "(self) -> tuple[numpy.ndarray, list[int]]:", "funcdef": "def"}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"fullname": "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview", "modulename": "cpdbench.dataset.CPD2DFromFileDataset", "qualname": "CPD2DFromFileDataset.get_validation_preview", "kind": "function", "doc": "A 2D ndarray containing the timeseries (time x feature)
\n
Return a smaller part of the complete signal for fast runtime validation.
\n\n\n\n", "signature": "(self) -> tuple[numpy.ndarray, list[int]]:", "funcdef": "def"}, "cpdbench.dataset.CPD2DNdarrayDataset": {"fullname": "cpdbench.dataset.CPD2DNdarrayDataset", "modulename": "cpdbench.dataset.CPD2DNdarrayDataset", "kind": "module", "doc": "\n"}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset": {"fullname": "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset", "modulename": "cpdbench.dataset.CPD2DNdarrayDataset", "qualname": "CPD2DNdarrayDataset", "kind": "class", "doc": "A 2D ndarray containing the timeseries (time x feature)
\n
Abstract class representing a dataset.
\n", "bases": "cpdbench.dataset.CPDDataset.CPDDataset"}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.__init__": {"fullname": "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.__init__", "modulename": "cpdbench.dataset.CPD2DNdarrayDataset", "qualname": "CPD2DNdarrayDataset.__init__", "kind": "function", "doc": "\n", "signature": "(numpy_array, ground_truths)"}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"fullname": "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview", "modulename": "cpdbench.dataset.CPD2DNdarrayDataset", "qualname": "CPD2DNdarrayDataset.get_validation_preview", "kind": "function", "doc": "Return a smaller part of the complete signal for fast runtime validation.
\n\n\n\n", "signature": "(self) -> tuple[numpy.ndarray, list[int]]:", "funcdef": "def"}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"fullname": "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init", "modulename": "cpdbench.dataset.CPD2DNdarrayDataset", "qualname": "CPD2DNdarrayDataset.init", "kind": "function", "doc": "A 2D ndarray containing the timeseries (time x feature)
\n
Initialization method to prepare the dataset.\nExamples: Open a file, open a db connection etc.
\n", "signature": "(self) -> None:", "funcdef": "def"}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"fullname": "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal", "modulename": "cpdbench.dataset.CPD2DNdarrayDataset", "qualname": "CPD2DNdarrayDataset.get_signal", "kind": "function", "doc": "Returns the timeseries as numpy array.
\n\n\n\n", "signature": "(self) -> tuple[numpy.ndarray, list[int]]:", "funcdef": "def"}, "cpdbench.dataset.CPDDataset": {"fullname": "cpdbench.dataset.CPDDataset", "modulename": "cpdbench.dataset.CPDDataset", "kind": "module", "doc": "\n"}, "cpdbench.dataset.CPDDataset.CPDDataset": {"fullname": "cpdbench.dataset.CPDDataset.CPDDataset", "modulename": "cpdbench.dataset.CPDDataset", "qualname": "CPDDataset", "kind": "class", "doc": "A 2D ndarray containing the timeseries (time x feature)
\n
Abstract class representing a dataset.
\n", "bases": "abc.ABC"}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"fullname": "cpdbench.dataset.CPDDataset.CPDDataset.init", "modulename": "cpdbench.dataset.CPDDataset", "qualname": "CPDDataset.init", "kind": "function", "doc": "Initialization method to prepare the dataset.\nExamples: Open a file, open a db connection etc.
\n", "signature": "(self) -> None:", "funcdef": "def"}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"fullname": "cpdbench.dataset.CPDDataset.CPDDataset.get_signal", "modulename": "cpdbench.dataset.CPDDataset", "qualname": "CPDDataset.get_signal", "kind": "function", "doc": "Returns the timeseries as numpy array.
\n\n\n\n", "signature": "(self) -> tuple[numpy.ndarray, list[int]]:", "funcdef": "def"}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"fullname": "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview", "modulename": "cpdbench.dataset.CPDDataset", "qualname": "CPDDataset.get_validation_preview", "kind": "function", "doc": "A 2D ndarray containing the timeseries (time x feature)
\n
Return a smaller part of the complete signal for fast runtime validation.
\n\n\n\n", "signature": "(self) -> tuple[numpy.ndarray, list[int]]:", "funcdef": "def"}, "cpdbench.examples": {"fullname": "cpdbench.examples", "modulename": "cpdbench.examples", "kind": "module", "doc": "\n"}, "cpdbench.examples.ExampleAlgorithms": {"fullname": "cpdbench.examples.ExampleAlgorithms", "modulename": "cpdbench.examples.ExampleAlgorithms", "kind": "module", "doc": "\n"}, "cpdbench.examples.ExampleAlgorithms.numpy_array_accesses": {"fullname": "cpdbench.examples.ExampleAlgorithms.numpy_array_accesses", "modulename": "cpdbench.examples.ExampleAlgorithms", "qualname": "numpy_array_accesses", "kind": "function", "doc": "\n", "signature": "(dataset, array_indexes):", "funcdef": "def"}, "cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"fullname": "cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst", "modulename": "cpdbench.examples.ExampleAlgorithms", "qualname": "algorithm_execute_single_esst", "kind": "function", "doc": "A 2D ndarray containing the timeseries (time x feature)
\n
Uses SST as implemented in the changepoynt library as algorithm.
\n", "signature": "(signal, window_length):", "funcdef": "def"}, "cpdbench.examples.ExampleDatasets": {"fullname": "cpdbench.examples.ExampleDatasets", "modulename": "cpdbench.examples.ExampleDatasets", "kind": "module", "doc": "\n"}, "cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"fullname": "cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file", "modulename": "cpdbench.examples.ExampleDatasets", "qualname": "get_extreme_large_dataset_from_file", "kind": "function", "doc": "\n", "signature": "():", "funcdef": "def"}, "cpdbench.examples.ExampleDatasets.dataset_get_apple_dataset": {"fullname": "cpdbench.examples.ExampleDatasets.dataset_get_apple_dataset", "modulename": "cpdbench.examples.ExampleDatasets", "qualname": "dataset_get_apple_dataset", "kind": "function", "doc": "\n", "signature": "():", "funcdef": "def"}, "cpdbench.examples.ExampleDatasets.dataset_get_bitcoin_dataset": {"fullname": "cpdbench.examples.ExampleDatasets.dataset_get_bitcoin_dataset", "modulename": "cpdbench.examples.ExampleDatasets", "qualname": "dataset_get_bitcoin_dataset", "kind": "function", "doc": "\n", "signature": "():", "funcdef": "def"}, "cpdbench.examples.ExampleMetrics": {"fullname": "cpdbench.examples.ExampleMetrics", "modulename": "cpdbench.examples.ExampleMetrics", "kind": "module", "doc": "\n"}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"fullname": "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows", "modulename": "cpdbench.examples.ExampleMetrics", "qualname": "metric_accuracy_in_allowed_windows", "kind": "function", "doc": "Calculate the accuracy with a small deviation window.\nThe result is the percentage of ground truth values, for which the algorithm got at least one fitting index in the\nsurrounding window. The scores are ignored.
\n", "signature": "(indexes, scores, ground_truth, *, window_size):", "funcdef": "def"}, "cpdbench.examples.Example_Parameters": {"fullname": "cpdbench.examples.Example_Parameters", "modulename": "cpdbench.examples.Example_Parameters", "kind": "module", "doc": "\n"}, "cpdbench.examples.Example_Parameters.cpdb": {"fullname": "cpdbench.examples.Example_Parameters.cpdb", "modulename": "cpdbench.examples.Example_Parameters", "qualname": "cpdb", "kind": "variable", "doc": "\n", "default_value": "<cpdbench.CPDBench.CPDBench object>"}, "cpdbench.examples.Example_Parameters.get_apple_dataset": {"fullname": "cpdbench.examples.Example_Parameters.get_apple_dataset", "modulename": "cpdbench.examples.Example_Parameters", "qualname": "get_apple_dataset", "kind": "function", "doc": "\n", "signature": "():", "funcdef": "def"}, "cpdbench.examples.Example_Parameters.get_bitcoin_dataset": {"fullname": "cpdbench.examples.Example_Parameters.get_bitcoin_dataset", "modulename": "cpdbench.examples.Example_Parameters", "qualname": "get_bitcoin_dataset", "kind": "function", "doc": "\n", "signature": "():", "funcdef": "def"}, "cpdbench.examples.Example_Parameters.execute_esst_test": {"fullname": "cpdbench.examples.Example_Parameters.execute_esst_test", "modulename": "cpdbench.examples.Example_Parameters", "qualname": "execute_esst_test", "kind": "function", "doc": "\n", "signature": "(signal, *, window_length):", "funcdef": "def"}, "cpdbench.examples.Example_Parameters.calc_accuracy": {"fullname": "cpdbench.examples.Example_Parameters.calc_accuracy", "modulename": "cpdbench.examples.Example_Parameters", "qualname": "calc_accuracy", "kind": "function", "doc": "\n", "signature": "(indexes, scores, ground_truth, *, window_size):", "funcdef": "def"}, "cpdbench.examples.Example_Simple": {"fullname": "cpdbench.examples.Example_Simple", "modulename": "cpdbench.examples.Example_Simple", "kind": "module", "doc": "\n"}, "cpdbench.examples.Example_Simple.cpdb": {"fullname": "cpdbench.examples.Example_Simple.cpdb", "modulename": "cpdbench.examples.Example_Simple", "qualname": "cpdb", "kind": "variable", "doc": "\n", "default_value": "<cpdbench.CPDBench.CPDBench object>"}, "cpdbench.examples.Example_Simple.get_apple_dataset": {"fullname": "cpdbench.examples.Example_Simple.get_apple_dataset", "modulename": "cpdbench.examples.Example_Simple", "qualname": "get_apple_dataset", "kind": "function", "doc": "\n", "signature": "():", "funcdef": "def"}, "cpdbench.examples.Example_Simple.get_bitcoin_dataset": {"fullname": "cpdbench.examples.Example_Simple.get_bitcoin_dataset", "modulename": "cpdbench.examples.Example_Simple", "qualname": "get_bitcoin_dataset", "kind": "function", "doc": "\n", "signature": "():", "funcdef": "def"}, "cpdbench.examples.Example_Simple.execute_esst_test": {"fullname": "cpdbench.examples.Example_Simple.execute_esst_test", "modulename": "cpdbench.examples.Example_Simple", "qualname": "execute_esst_test", "kind": "function", "doc": "\n", "signature": "(signal):", "funcdef": "def"}, "cpdbench.examples.Example_Simple.calc_accuracy": {"fullname": "cpdbench.examples.Example_Simple.calc_accuracy", "modulename": "cpdbench.examples.Example_Simple", "qualname": "calc_accuracy", "kind": "function", "doc": "\n", "signature": "(indexes, scores, ground_truth):", "funcdef": "def"}, "cpdbench.examples.Example_VeryLargeDataset": {"fullname": "cpdbench.examples.Example_VeryLargeDataset", "modulename": "cpdbench.examples.Example_VeryLargeDataset", "kind": "module", "doc": "\n"}, "cpdbench.examples.Example_VeryLargeDataset.cpdb": {"fullname": "cpdbench.examples.Example_VeryLargeDataset.cpdb", "modulename": "cpdbench.examples.Example_VeryLargeDataset", "qualname": "cpdb", "kind": "variable", "doc": "\n", "default_value": "<cpdbench.CPDBench.CPDBench object>"}, "cpdbench.examples.Example_VeryLargeDataset.get_large_dataset": {"fullname": "cpdbench.examples.Example_VeryLargeDataset.get_large_dataset", "modulename": "cpdbench.examples.Example_VeryLargeDataset", "qualname": "get_large_dataset", "kind": "function", "doc": "\n", "signature": "():", "funcdef": "def"}, "cpdbench.examples.Example_VeryLargeDataset.execute_algorithm": {"fullname": "cpdbench.examples.Example_VeryLargeDataset.execute_algorithm", "modulename": "cpdbench.examples.Example_VeryLargeDataset", "qualname": "execute_algorithm", "kind": "function", "doc": "\n", "signature": "(dataset, *, array_indexes):", "funcdef": "def"}, "cpdbench.examples.Example_VeryLargeDataset.compute_metric": {"fullname": "cpdbench.examples.Example_VeryLargeDataset.compute_metric", "modulename": "cpdbench.examples.Example_VeryLargeDataset", "qualname": "compute_metric", "kind": "function", "doc": "\n", "signature": "(indexes, confidences, ground_truths):", "funcdef": "def"}, "cpdbench.exception": {"fullname": "cpdbench.exception", "modulename": "cpdbench.exception", "kind": "module", "doc": "This package contains all custom exception classes\nused by the framework.
\n"}, "cpdbench.exception.AlgorithmExecutionException": {"fullname": "cpdbench.exception.AlgorithmExecutionException", "modulename": "cpdbench.exception.AlgorithmExecutionException", "kind": "module", "doc": "\n"}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"fullname": "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException", "modulename": "cpdbench.exception.AlgorithmExecutionException", "qualname": "AlgorithmExecutionException", "kind": "class", "doc": "Exception type when the execution of an algorithm on a dataset has failed
\n", "bases": "cpdbench.exception.CPDExecutionException.CPDExecutionException"}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.__init__": {"fullname": "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.__init__", "modulename": "cpdbench.exception.AlgorithmExecutionException", "qualname": "AlgorithmExecutionException.__init__", "kind": "function", "doc": "\n", "signature": "(algorithm_function, dataset_function)"}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"fullname": "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg", "modulename": "cpdbench.exception.AlgorithmExecutionException", "qualname": "AlgorithmExecutionException.standard_msg", "kind": "variable", "doc": "\n", "default_value": "'Error while executing the algorithm {0} on dataset {1}'"}, "cpdbench.exception.CPDExecutionException": {"fullname": "cpdbench.exception.CPDExecutionException", "modulename": "cpdbench.exception.CPDExecutionException", "kind": "module", "doc": "\n"}, "cpdbench.exception.CPDExecutionException.CPDExecutionException": {"fullname": "cpdbench.exception.CPDExecutionException.CPDExecutionException", "modulename": "cpdbench.exception.CPDExecutionException", "qualname": "CPDExecutionException", "kind": "class", "doc": "General Exception type when something goes wrong in dataset fetching, algorithm execution or metric\ncalculation.
\n", "bases": "builtins.Exception"}, "cpdbench.exception.CPDExecutionException.CPDExecutionException.__init__": {"fullname": "cpdbench.exception.CPDExecutionException.CPDExecutionException.__init__", "modulename": "cpdbench.exception.CPDExecutionException", "qualname": "CPDExecutionException.__init__", "kind": "function", "doc": "\n", "signature": "(message)"}, "cpdbench.exception.ConfigurationException": {"fullname": "cpdbench.exception.ConfigurationException", "modulename": "cpdbench.exception.ConfigurationException", "kind": "module", "doc": "\n"}, "cpdbench.exception.ConfigurationException.ConfigurationException": {"fullname": "cpdbench.exception.ConfigurationException.ConfigurationException", "modulename": "cpdbench.exception.ConfigurationException", "qualname": "ConfigurationException", "kind": "class", "doc": "General error for inconsistencies and errors in the given config file.
\n", "bases": "builtins.Exception"}, "cpdbench.exception.ConfigurationException.ConfigurationException.__init__": {"fullname": "cpdbench.exception.ConfigurationException.ConfigurationException.__init__", "modulename": "cpdbench.exception.ConfigurationException", "qualname": "ConfigurationException.__init__", "kind": "function", "doc": "\n", "signature": "(config_variable)"}, "cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"fullname": "cpdbench.exception.ConfigurationException.ConfigurationException.exc_message", "modulename": "cpdbench.exception.ConfigurationException", "qualname": "ConfigurationException.exc_message", "kind": "variable", "doc": "\n", "default_value": "'Error in configuration file: Invalid value for {0}, using default value.'"}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"fullname": "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException", "modulename": "cpdbench.exception.ConfigurationException", "qualname": "ConfigurationFileNotFoundException", "kind": "class", "doc": "Error if a given config file path does not exist
\n", "bases": "builtins.Exception"}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.__init__": {"fullname": "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.__init__", "modulename": "cpdbench.exception.ConfigurationException", "qualname": "ConfigurationFileNotFoundException.__init__", "kind": "function", "doc": "\n", "signature": "(config_variable)"}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"fullname": "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message", "modulename": "cpdbench.exception.ConfigurationException", "qualname": "ConfigurationFileNotFoundException.exc_message", "kind": "variable", "doc": "\n", "default_value": "'Given config file path [{0}] does not exist. Using default config values.'"}, "cpdbench.exception.DatasetFetchException": {"fullname": "cpdbench.exception.DatasetFetchException", "modulename": "cpdbench.exception.DatasetFetchException", "kind": "module", "doc": "\n"}, "cpdbench.exception.DatasetFetchException.DatasetFetchException": {"fullname": "cpdbench.exception.DatasetFetchException.DatasetFetchException", "modulename": "cpdbench.exception.DatasetFetchException", "qualname": "DatasetFetchException", "kind": "class", "doc": "Exception type when something goes wrong while loading a dataset
\n", "bases": "cpdbench.exception.CPDExecutionException.CPDExecutionException"}, "cpdbench.exception.DatasetFetchException.DatasetFetchException.__init__": {"fullname": "cpdbench.exception.DatasetFetchException.DatasetFetchException.__init__", "modulename": "cpdbench.exception.DatasetFetchException", "qualname": "DatasetFetchException.__init__", "kind": "function", "doc": "\n", "signature": "(message)"}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"fullname": "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException", "modulename": "cpdbench.exception.DatasetFetchException", "qualname": "CPDDatasetCreationException", "kind": "class", "doc": "Exception type when the initialization and creation of the CPDDataset object has failed
\n", "bases": "DatasetFetchException"}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.__init__": {"fullname": "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.__init__", "modulename": "cpdbench.exception.DatasetFetchException", "qualname": "CPDDatasetCreationException.__init__", "kind": "function", "doc": "\n", "signature": "(dataset_function)"}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"fullname": "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset", "modulename": "cpdbench.exception.DatasetFetchException", "qualname": "CPDDatasetCreationException.standard_msg_create_dataset", "kind": "variable", "doc": "\n", "default_value": "'Error while creating the CPDDataset object with the {0} function'"}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"fullname": "cpdbench.exception.DatasetFetchException.FeatureLoadingException", "modulename": "cpdbench.exception.DatasetFetchException", "qualname": "FeatureLoadingException", "kind": "class", "doc": "Exception type when the loading of a feature of a CPDDataset has failed
\n", "bases": "DatasetFetchException"}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.__init__": {"fullname": "cpdbench.exception.DatasetFetchException.FeatureLoadingException.__init__", "modulename": "cpdbench.exception.DatasetFetchException", "qualname": "FeatureLoadingException.__init__", "kind": "function", "doc": "\n", "signature": "(dataset_function, feature)"}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"fullname": "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature", "modulename": "cpdbench.exception.DatasetFetchException", "qualname": "FeatureLoadingException.standard_msg_load_feature", "kind": "variable", "doc": "\n", "default_value": "'Error while loading feature {0} of the CPDDataset from function {1}'"}, "cpdbench.exception.DatasetFetchException.SignalLoadingException": {"fullname": "cpdbench.exception.DatasetFetchException.SignalLoadingException", "modulename": "cpdbench.exception.DatasetFetchException", "qualname": "SignalLoadingException", "kind": "class", "doc": "Exception type when the loading of a signal of a CPDDataset has failed
\n", "bases": "DatasetFetchException"}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.__init__": {"fullname": "cpdbench.exception.DatasetFetchException.SignalLoadingException.__init__", "modulename": "cpdbench.exception.DatasetFetchException", "qualname": "SignalLoadingException.__init__", "kind": "function", "doc": "\n", "signature": "(dataset_function)"}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"fullname": "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal", "modulename": "cpdbench.exception.DatasetFetchException", "qualname": "SignalLoadingException.standard_msg_load_signal", "kind": "variable", "doc": "\n", "default_value": "'Error while loading the signal of the CPDDataset from function {0}'"}, "cpdbench.exception.MetricExecutionException": {"fullname": "cpdbench.exception.MetricExecutionException", "modulename": "cpdbench.exception.MetricExecutionException", "kind": "module", "doc": "\n"}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"fullname": "cpdbench.exception.MetricExecutionException.MetricExecutionException", "modulename": "cpdbench.exception.MetricExecutionException", "qualname": "MetricExecutionException", "kind": "class", "doc": "Exception type when the execution of a metric on an algorithm result has failed
\n", "bases": "cpdbench.exception.CPDExecutionException.CPDExecutionException"}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.__init__": {"fullname": "cpdbench.exception.MetricExecutionException.MetricExecutionException.__init__", "modulename": "cpdbench.exception.MetricExecutionException", "qualname": "MetricExecutionException.__init__", "kind": "function", "doc": "\n", "signature": "(metric_function, algorithm_function, dataset_function)"}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"fullname": "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg", "modulename": "cpdbench.exception.MetricExecutionException", "qualname": "MetricExecutionException.standard_msg", "kind": "variable", "doc": "\n", "default_value": "'Error while executing the metric {0} on algorithm {1} (dataset {2})'"}, "cpdbench.exception.ResultSetInconsistentException": {"fullname": "cpdbench.exception.ResultSetInconsistentException", "modulename": "cpdbench.exception.ResultSetInconsistentException", "kind": "module", "doc": "\n"}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"fullname": "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException", "modulename": "cpdbench.exception.ResultSetInconsistentException", "qualname": "ResultSetInconsistentException", "kind": "class", "doc": "Exception type for inconsistencies in a result object.\nFor example when an algorithm result is to be added for an algorithm which does not exist.
\n", "bases": "builtins.Exception"}, "cpdbench.exception.UserParameterDoesNotExistException": {"fullname": "cpdbench.exception.UserParameterDoesNotExistException", "modulename": "cpdbench.exception.UserParameterDoesNotExistException", "kind": "module", "doc": "\n"}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"fullname": "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException", "modulename": "cpdbench.exception.UserParameterDoesNotExistException", "qualname": "UserParameterDoesNotExistException", "kind": "class", "doc": "Exception type when a needed user parameter in a dataset, algorithm or metric does not exist in the config\nfile.
\n", "bases": "builtins.Exception"}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.__init__": {"fullname": "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.__init__", "modulename": "cpdbench.exception.UserParameterDoesNotExistException", "qualname": "UserParameterDoesNotExistException.__init__", "kind": "function", "doc": "\n", "signature": "(param_name, function_name)"}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"fullname": "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text", "modulename": "cpdbench.exception.UserParameterDoesNotExistException", "qualname": "UserParameterDoesNotExistException.msg_text", "kind": "variable", "doc": "\n", "default_value": "'The user parameter [{0}] is needed for running [{1}], but does not exist in the given config file.'"}, "cpdbench.exception.ValidationException": {"fullname": "cpdbench.exception.ValidationException", "modulename": "cpdbench.exception.ValidationException", "kind": "module", "doc": "\n"}, "cpdbench.exception.ValidationException.ValidationException": {"fullname": "cpdbench.exception.ValidationException.ValidationException", "modulename": "cpdbench.exception.ValidationException", "qualname": "ValidationException", "kind": "class", "doc": "General exception type when some validation went wrong.
\n", "bases": "builtins.Exception"}, "cpdbench.exception.ValidationException.InputValidationException": {"fullname": "cpdbench.exception.ValidationException.InputValidationException", "modulename": "cpdbench.exception.ValidationException", "qualname": "InputValidationException", "kind": "class", "doc": "More specific validation exception when something about the input parameters is wrong.
\n", "bases": "ValidationException"}, "cpdbench.exception.ValidationException.AlgorithmValidationException": {"fullname": "cpdbench.exception.ValidationException.AlgorithmValidationException", "modulename": "cpdbench.exception.ValidationException", "qualname": "AlgorithmValidationException", "kind": "class", "doc": "Validation exception when runtime validation of an algorithm fails.
\n", "bases": "ValidationException"}, "cpdbench.exception.ValidationException.MetricValidationException": {"fullname": "cpdbench.exception.ValidationException.MetricValidationException", "modulename": "cpdbench.exception.ValidationException", "qualname": "MetricValidationException", "kind": "class", "doc": "Validation exception when runtime validation of a metric fails.
\n", "bases": "ValidationException"}, "cpdbench.exception.ValidationException.DatasetValidationException": {"fullname": "cpdbench.exception.ValidationException.DatasetValidationException", "modulename": "cpdbench.exception.ValidationException", "qualname": "DatasetValidationException", "kind": "class", "doc": "Validation exception when runtime validation of a dataset fails.
\n", "bases": "ValidationException"}, "cpdbench.task": {"fullname": "cpdbench.task", "modulename": "cpdbench.task", "kind": "module", "doc": "This package contains the Task abstract class, its implementations,\nand the factory to create task objects.
\n"}, "cpdbench.task.AlgorithmExecutionTask": {"fullname": "cpdbench.task.AlgorithmExecutionTask", "modulename": "cpdbench.task.AlgorithmExecutionTask", "kind": "module", "doc": "\n"}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"fullname": "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask", "modulename": "cpdbench.task.AlgorithmExecutionTask", "qualname": "AlgorithmExecutionTask", "kind": "class", "doc": "Abstract class for a Task object which is a work package to be executed by the framework.\nA task has a name, can be validated, and executed, and can have some parameters.
\n", "bases": "cpdbench.task.Task.Task"}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"fullname": "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__", "modulename": "cpdbench.task.AlgorithmExecutionTask", "qualname": "AlgorithmExecutionTask.__init__", "kind": "function", "doc": "General constructor for all task objects.
\n\nValidates the task statically by checking task details before running it.\nThrows an exception if the validation fails.
\n", "signature": "(self) -> None:", "funcdef": "def"}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"fullname": "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input", "modulename": "cpdbench.task.AlgorithmExecutionTask", "qualname": "AlgorithmExecutionTask.validate_input", "kind": "function", "doc": "Validates the task in combination with some input arguments.\nThrows an exception if the validation fails.
\n", "signature": "(\tself,\tdata: numpy.ndarray) -> tuple[collections.abc.Iterable, collections.abc.Iterable]:", "funcdef": "def"}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"fullname": "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute", "modulename": "cpdbench.task.AlgorithmExecutionTask", "qualname": "AlgorithmExecutionTask.execute", "kind": "function", "doc": "Executes the task. Can take an arbitrary number of arguments and can produce any result.
\n", "signature": "(\tself,\tdata: numpy.ndarray) -> tuple[collections.abc.Iterable, collections.abc.Iterable]:", "funcdef": "def"}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"fullname": "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name", "modulename": "cpdbench.task.AlgorithmExecutionTask", "qualname": "AlgorithmExecutionTask.get_task_name", "kind": "function", "doc": "Returns a descriptive name for the task.
\n\n\n\n", "signature": "(self) -> str:", "funcdef": "def"}, "cpdbench.task.DatasetFetchTask": {"fullname": "cpdbench.task.DatasetFetchTask", "modulename": "cpdbench.task.DatasetFetchTask", "kind": "module", "doc": "\n"}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"fullname": "cpdbench.task.DatasetFetchTask.DatasetFetchTask", "modulename": "cpdbench.task.DatasetFetchTask", "qualname": "DatasetFetchTask", "kind": "class", "doc": "task name as string
\n
Abstract class for a Task object which is a work package to be executed by the framework.\nA task has a name, can be validated, and executed, and can have some parameters.
\n", "bases": "cpdbench.task.Task.Task"}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"fullname": "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__", "modulename": "cpdbench.task.DatasetFetchTask", "qualname": "DatasetFetchTask.__init__", "kind": "function", "doc": "General constructor for all task objects.
\n\nValidates the task statically by checking task details before running it.\nThrows an exception if the validation fails.
\n", "signature": "(self) -> None:", "funcdef": "def"}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"fullname": "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input", "modulename": "cpdbench.task.DatasetFetchTask", "qualname": "DatasetFetchTask.validate_input", "kind": "function", "doc": "Validates the task in combination with some input arguments.\nThrows an exception if the validation fails.
\n", "signature": "(\tself,\t*args) -> <module 'cpdbench.dataset.CPDDataset' from '/Users/dominik/Documents/Projects/CPD-Bench/src/cpdbench/dataset/CPDDataset.py'>:", "funcdef": "def"}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"fullname": "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute", "modulename": "cpdbench.task.DatasetFetchTask", "qualname": "DatasetFetchTask.execute", "kind": "function", "doc": "Executes the task. Can take an arbitrary number of arguments and can produce any result.
\n", "signature": "(\tself) -> <module 'cpdbench.dataset.CPDDataset' from '/Users/dominik/Documents/Projects/CPD-Bench/src/cpdbench/dataset/CPDDataset.py'>:", "funcdef": "def"}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"fullname": "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name", "modulename": "cpdbench.task.DatasetFetchTask", "qualname": "DatasetFetchTask.get_task_name", "kind": "function", "doc": "Returns a descriptive name for the task.
\n\n\n\n", "signature": "(self) -> str:", "funcdef": "def"}, "cpdbench.task.MetricExecutionTask": {"fullname": "cpdbench.task.MetricExecutionTask", "modulename": "cpdbench.task.MetricExecutionTask", "kind": "module", "doc": "\n"}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"fullname": "cpdbench.task.MetricExecutionTask.MetricExecutionTask", "modulename": "cpdbench.task.MetricExecutionTask", "qualname": "MetricExecutionTask", "kind": "class", "doc": "task name as string
\n
Abstract class for a Task object which is a work package to be executed by the framework.\nA task has a name, can be validated, and executed, and can have some parameters.
\n", "bases": "cpdbench.task.Task.Task"}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"fullname": "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__", "modulename": "cpdbench.task.MetricExecutionTask", "qualname": "MetricExecutionTask.__init__", "kind": "function", "doc": "General constructor for all task objects.
\n\nExecutes the task. Can take an arbitrary number of arguments and can produce any result.
\n", "signature": "(\tself,\tindexes: collections.abc.Iterable,\tscores: collections.abc.Iterable,\tground_truths: collections.abc.Iterable) -> float:", "funcdef": "def"}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"fullname": "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task", "modulename": "cpdbench.task.MetricExecutionTask", "qualname": "MetricExecutionTask.validate_task", "kind": "function", "doc": "Validates the task statically by checking task details before running it.\nThrows an exception if the validation fails.
\n", "signature": "(self) -> None:", "funcdef": "def"}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"fullname": "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input", "modulename": "cpdbench.task.MetricExecutionTask", "qualname": "MetricExecutionTask.validate_input", "kind": "function", "doc": "Validates the task in combination with some input arguments.\nThrows an exception if the validation fails.
\n", "signature": "(\tself,\tindexes: collections.abc.Iterable,\tscores: collections.abc.Iterable,\tground_truths: collections.abc.Iterable) -> float:", "funcdef": "def"}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"fullname": "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name", "modulename": "cpdbench.task.MetricExecutionTask", "qualname": "MetricExecutionTask.get_task_name", "kind": "function", "doc": "Returns a descriptive name for the task.
\n\n\n\n", "signature": "(self) -> str:", "funcdef": "def"}, "cpdbench.task.Task": {"fullname": "cpdbench.task.Task", "modulename": "cpdbench.task.Task", "kind": "module", "doc": "\n"}, "cpdbench.task.Task.TaskType": {"fullname": "cpdbench.task.Task.TaskType", "modulename": "cpdbench.task.Task", "qualname": "TaskType", "kind": "class", "doc": "task name as string
\n
Enum of pre-defined task types needed for the CPDBench
\n", "bases": "enum.Enum"}, "cpdbench.task.Task.TaskType.DATASET_FETCH": {"fullname": "cpdbench.task.Task.TaskType.DATASET_FETCH", "modulename": "cpdbench.task.Task", "qualname": "TaskType.DATASET_FETCH", "kind": "variable", "doc": "\n", "default_value": "<TaskType.DATASET_FETCH: 1>"}, "cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION": {"fullname": "cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION", "modulename": "cpdbench.task.Task", "qualname": "TaskType.ALGORITHM_EXECUTION", "kind": "variable", "doc": "\n", "default_value": "<TaskType.ALGORITHM_EXECUTION: 2>"}, "cpdbench.task.Task.TaskType.METRIC_EXECUTION": {"fullname": "cpdbench.task.Task.TaskType.METRIC_EXECUTION", "modulename": "cpdbench.task.Task", "qualname": "TaskType.METRIC_EXECUTION", "kind": "variable", "doc": "\n", "default_value": "<TaskType.METRIC_EXECUTION: 3>"}, "cpdbench.task.Task.Task": {"fullname": "cpdbench.task.Task.Task", "modulename": "cpdbench.task.Task", "qualname": "Task", "kind": "class", "doc": "Abstract class for a Task object which is a work package to be executed by the framework.\nA task has a name, can be validated, and executed, and can have some parameters.
\n", "bases": "abc.ABC"}, "cpdbench.task.Task.Task.__init__": {"fullname": "cpdbench.task.Task.Task.__init__", "modulename": "cpdbench.task.Task", "qualname": "Task.__init__", "kind": "function", "doc": "General constructor for all task objects.
\n\nExecutes the task. Can take an arbitrary number of arguments and can produce any result.
\n", "signature": "(self, *args) -> <built-in function any>:", "funcdef": "def"}, "cpdbench.task.Task.Task.validate_task": {"fullname": "cpdbench.task.Task.Task.validate_task", "modulename": "cpdbench.task.Task", "qualname": "Task.validate_task", "kind": "function", "doc": "Validates the task statically by checking task details before running it.\nThrows an exception if the validation fails.
\n", "signature": "(self) -> None:", "funcdef": "def"}, "cpdbench.task.Task.Task.validate_input": {"fullname": "cpdbench.task.Task.Task.validate_input", "modulename": "cpdbench.task.Task", "qualname": "Task.validate_input", "kind": "function", "doc": "Validates the task in combination with some input arguments.\nThrows an exception if the validation fails.
\n", "signature": "(self, *args) -> <built-in function any>:", "funcdef": "def"}, "cpdbench.task.Task.Task.get_task_name": {"fullname": "cpdbench.task.Task.Task.get_task_name", "modulename": "cpdbench.task.Task", "qualname": "Task.get_task_name", "kind": "function", "doc": "Returns a descriptive name for the task.
\n\n\n\n", "signature": "(self) -> str:", "funcdef": "def"}, "cpdbench.task.Task.Task.get_param_dict": {"fullname": "cpdbench.task.Task.Task.get_param_dict", "modulename": "cpdbench.task.Task", "qualname": "Task.get_param_dict", "kind": "function", "doc": "task name as string
\n
Returns the parameters this task contains.
\n\n\n\n", "signature": "(self) -> dict:", "funcdef": "def"}, "cpdbench.task.TaskFactory": {"fullname": "cpdbench.task.TaskFactory", "modulename": "cpdbench.task.TaskFactory", "kind": "module", "doc": "\n"}, "cpdbench.task.TaskFactory.TaskFactory": {"fullname": "cpdbench.task.TaskFactory.TaskFactory", "modulename": "cpdbench.task.TaskFactory", "qualname": "TaskFactory", "kind": "class", "doc": "the parameters as dictionary
\n
Abstract factory for creating task objects
\n"}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"fullname": "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function", "modulename": "cpdbench.task.TaskFactory", "qualname": "TaskFactory.create_task_from_function", "kind": "function", "doc": "Creates one task for an unparametrized function.
\n\n\n\n", "signature": "(\tself,\tfunction: Callable,\ttask_type: cpdbench.task.Task.TaskType) -> cpdbench.task.Task.Task:", "funcdef": "def"}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"fullname": "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters", "modulename": "cpdbench.task.TaskFactory", "qualname": "TaskFactory.create_tasks_with_parameters", "kind": "function", "doc": "the constructed task object
\n
Creates correct task objects based on the given task type and the needed parameters defined in the user\nconfig. Because of this, this method can potentially output multiple tasks with the same function\nbut different parameters.
\n\n\n\n", "signature": "(\tself,\tfunction: Callable,\ttask_type: cpdbench.task.Task.TaskType) -> list[cpdbench.task.Task.Task]:", "funcdef": "def"}, "cpdbench.utils": {"fullname": "cpdbench.utils", "modulename": "cpdbench.utils", "kind": "module", "doc": "the constructed task objects
\n
A package containing different utility classes, which are used everywhere in the framework.\nEspecially logging and configuration classes.
\n"}, "cpdbench.utils.BenchConfig": {"fullname": "cpdbench.utils.BenchConfig", "modulename": "cpdbench.utils.BenchConfig", "kind": "module", "doc": "The global configuration Singleton module.\nContains all configurable parameters for the bench and functions\nto read a given config.yml file.
\n\nTo be used correctly the function load_config(config_file) has to be called first.\nAfter this the other functions can be used.
\n"}, "cpdbench.utils.BenchConfig.logging_file_name": {"fullname": "cpdbench.utils.BenchConfig.logging_file_name", "modulename": "cpdbench.utils.BenchConfig", "qualname": "logging_file_name", "kind": "variable", "doc": "\n", "annotation": ": str", "default_value": "'cpdbench-log.txt'"}, "cpdbench.utils.BenchConfig.logging_level": {"fullname": "cpdbench.utils.BenchConfig.logging_level", "modulename": "cpdbench.utils.BenchConfig", "qualname": "logging_level", "kind": "variable", "doc": "\n", "annotation": ": int", "default_value": "20"}, "cpdbench.utils.BenchConfig.logging_console_level": {"fullname": "cpdbench.utils.BenchConfig.logging_console_level", "modulename": "cpdbench.utils.BenchConfig", "qualname": "logging_console_level", "kind": "variable", "doc": "\n", "annotation": ": int", "default_value": "40"}, "cpdbench.utils.BenchConfig.multiprocessing_enabled": {"fullname": "cpdbench.utils.BenchConfig.multiprocessing_enabled", "modulename": "cpdbench.utils.BenchConfig", "qualname": "multiprocessing_enabled", "kind": "variable", "doc": "\n", "default_value": "True"}, "cpdbench.utils.BenchConfig.result_file_name": {"fullname": "cpdbench.utils.BenchConfig.result_file_name", "modulename": "cpdbench.utils.BenchConfig", "qualname": "result_file_name", "kind": "variable", "doc": "\n", "annotation": ": str", "default_value": "'cpdbench-result.json'"}, "cpdbench.utils.BenchConfig.get_user_config": {"fullname": "cpdbench.utils.BenchConfig.get_user_config", "modulename": "cpdbench.utils.BenchConfig", "qualname": "get_user_config", "kind": "function", "doc": "Returns the UserConfig object if the BenchConfig was already initialized.\n:return the UserConfig object
\n", "signature": "() -> cpdbench.utils.UserConfig.UserConfig:", "funcdef": "def"}, "cpdbench.utils.BenchConfig.get_complete_config": {"fullname": "cpdbench.utils.BenchConfig.get_complete_config", "modulename": "cpdbench.utils.BenchConfig", "qualname": "get_complete_config", "kind": "function", "doc": "Returns the complete bench configuration including the user config as python dict.\n:return the config as dict
\n", "signature": "() -> dict:", "funcdef": "def"}, "cpdbench.utils.BenchConfig.load_config": {"fullname": "cpdbench.utils.BenchConfig.load_config", "modulename": "cpdbench.utils.BenchConfig", "qualname": "load_config", "kind": "function", "doc": "Initializes the BenchConfig object with the given config.yml file.\nIf the config_file param is None or the file does not exist, the bench will use the default parameters and this\nfunction returns false.
\n\n\n\n", "signature": "(config_file='config.yml') -> bool:", "funcdef": "def"}, "cpdbench.utils.Logger": {"fullname": "cpdbench.utils.Logger", "modulename": "cpdbench.utils.Logger", "kind": "module", "doc": "\n"}, "cpdbench.utils.Logger.init_logger": {"fullname": "cpdbench.utils.Logger.init_logger", "modulename": "cpdbench.utils.Logger", "qualname": "init_logger", "kind": "function", "doc": "\n", "signature": "():", "funcdef": "def"}, "cpdbench.utils.Logger.get_application_logger": {"fullname": "cpdbench.utils.Logger.get_application_logger", "modulename": "cpdbench.utils.Logger", "qualname": "get_application_logger", "kind": "function", "doc": "\n", "signature": "() -> logging.Logger:", "funcdef": "def"}, "cpdbench.utils.UserConfig": {"fullname": "cpdbench.utils.UserConfig", "modulename": "cpdbench.utils.UserConfig", "kind": "module", "doc": "\n"}, "cpdbench.utils.UserConfig.UserConfig": {"fullname": "cpdbench.utils.UserConfig.UserConfig", "modulename": "cpdbench.utils.UserConfig", "qualname": "UserConfig", "kind": "class", "doc": "True if the config could be loaded correctly, false otherwise.
\n
This class represents the part of the global config file which contains all user variables.\nThere are two types of user parameters/variables in this testbench:
\n\nConstructor for the UserConfig class
\n\nReturns the needed number of executions of each task for the given type depending on the amount of\nparameter sets
\n\n\n\n", "signature": "(self, tasks_type: cpdbench.task.Task.TaskType) -> int:", "funcdef": "def"}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"fullname": "cpdbench.utils.UserConfig.UserConfig.get_user_param", "modulename": "cpdbench.utils.UserConfig", "qualname": "UserConfig.get_user_param", "kind": "function", "doc": "the number of executions
\n
Returns the values of the given user parameter name.\nReturns a list because for execution variables multiple instances (for multiple runs) can be defined.\nThrows an exception if the parameter is not defined.
\n\n\n\n", "signature": "(self, param_name: str, task_type: cpdbench.task.Task.TaskType) -> list:", "funcdef": "def"}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"fullname": "cpdbench.utils.UserConfig.UserConfig.check_if_global_param", "modulename": "cpdbench.utils.UserConfig", "qualname": "UserConfig.check_if_global_param", "kind": "function", "doc": "a list of all possible values for the requested parameter
\n
Checks if the given parameter is a global one or an execution parameter.
\n\n\n\n", "signature": "(self, param_name: str) -> bool:", "funcdef": "def"}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"fullname": "cpdbench.utils.UserConfig.UserConfig.get_param_dict", "modulename": "cpdbench.utils.UserConfig", "qualname": "UserConfig.get_param_dict", "kind": "function", "doc": "True if the parameter is a global one. False otherwise.
\n
Returns all user params as dict for logging purposes.
\n\n\n\n", "signature": "(self) -> dict:", "funcdef": "def"}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"fullname": "cpdbench.utils.UserConfig.UserConfig.validate_user_config", "modulename": "cpdbench.utils.UserConfig", "qualname": "UserConfig.validate_user_config", "kind": "function", "doc": "the user param dict
\n
Validates the user config for common errors.\nThis method returns nothing if the validation is successful, and throws errors\nif something is wrong with the config, as the bench cannot continue with consistency\nerrors in the config.
\n", "signature": "(self) -> None:", "funcdef": "def"}, "cpdbench.utils.Utils": {"fullname": "cpdbench.utils.Utils", "modulename": "cpdbench.utils.Utils", "kind": "module", "doc": "\n"}, "cpdbench.utils.Utils.get_name_of_function": {"fullname": "cpdbench.utils.Utils.get_name_of_function", "modulename": "cpdbench.utils.Utils", "qualname": "get_name_of_function", "kind": "function", "doc": "Returns the name of the given function reference/object by using the inspect module
\n\n\n\n", "signature": "(function_ref: Callable) -> str:", "funcdef": "def"}}, "docInfo": {"cpdbench": {"qualname": 0, "fullname": 1, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.CPDBench": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.CPDBench.CPDBench": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 9}, "cpdbench.CPDBench.CPDBench.start": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 32, "bases": 0, "doc": 33}, "cpdbench.CPDBench.CPDBench.validate": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 37, "bases": 0, "doc": 43}, "cpdbench.CPDBench.CPDBench.dataset": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 10}, "cpdbench.CPDBench.CPDBench.algorithm": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 10}, "cpdbench.CPDBench.CPDBench.metric": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 10}, "cpdbench.control": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 19}, "cpdbench.control.CPDDatasetResult": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.control.CPDDatasetResult.ErrorType": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 14}, "cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 11, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 11, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 11, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 15}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 49, "bases": 0, "doc": 59}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 42}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 59, "bases": 0, "doc": 70}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 60, "bases": 0, "doc": 64}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 89, "bases": 0, "doc": 70}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 24}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 20}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 17}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 17}, "cpdbench.control.CPDFullResult": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.control.CPDFullResult.CPDFullResult": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 11}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 34, "bases": 0, "doc": 52}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 42, "bases": 0, "doc": 28}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 29}, "cpdbench.control.CPDResult": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.control.CPDResult.CPDResult": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 10}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 12}, "cpdbench.control.CPDValidationResult": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.control.CPDValidationResult.CPDValidationResult": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 9}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 61}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 29}, "cpdbench.control.DatasetExecutor": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 31}, "cpdbench.control.DatasetExecutor.DatasetExecutor.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 27, "bases": 0, "doc": 3}, "cpdbench.control.DatasetExecutor.DatasetExecutor.logger": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.control.DatasetExecutor.DatasetExecutor.execute": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 10}, "cpdbench.control.ExecutionController": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.control.ExecutionController.ExecutionController": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 24}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 39, "bases": 0, "doc": 52}, "cpdbench.control.TestbenchController": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.control.TestbenchController.TestrunType": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 7}, "cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 8, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 8, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 3, "doc": 141}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 81}, "cpdbench.control.TestbenchController.TestbenchController": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 40}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 74, "bases": 0, "doc": 52}, "cpdbench.control.TestrunController": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.control.TestrunController.TestrunController": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 33}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 39, "bases": 0, "doc": 52}, "cpdbench.control.ValidationRunController": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.control.ValidationRunController.ValidationRunController": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 30}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 39, "bases": 0, "doc": 52}, "cpdbench.dataset": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 20}, "cpdbench.dataset.CPD2DFromFileDataset": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 47}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 36, "bases": 0, "doc": 55}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.file_path": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.dtype": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 18}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 35, "bases": 0, "doc": 28}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 35, "bases": 0, "doc": 34}, "cpdbench.dataset.CPD2DNdarrayDataset": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 8}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 35, "bases": 0, "doc": 34}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 18}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 35, "bases": 0, "doc": 28}, "cpdbench.dataset.CPDDataset": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.dataset.CPDDataset.CPDDataset": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 8}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 18}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 35, "bases": 0, "doc": 28}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 35, "bases": 0, "doc": 34}, "cpdbench.examples": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.examples.ExampleAlgorithms": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.examples.ExampleAlgorithms.numpy_array_accesses": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 17, "bases": 0, "doc": 3}, "cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 17, "bases": 0, "doc": 13}, "cpdbench.examples.ExampleDatasets": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"qualname": 6, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 7, "bases": 0, "doc": 3}, "cpdbench.examples.ExampleDatasets.dataset_get_apple_dataset": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 7, "bases": 0, "doc": 3}, "cpdbench.examples.ExampleDatasets.dataset_get_bitcoin_dataset": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 7, "bases": 0, "doc": 3}, "cpdbench.examples.ExampleMetrics": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 33, "bases": 0, "doc": 38}, "cpdbench.examples.Example_Parameters": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.examples.Example_Parameters.cpdb": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 8, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.examples.Example_Parameters.get_apple_dataset": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 7, "bases": 0, "doc": 3}, "cpdbench.examples.Example_Parameters.get_bitcoin_dataset": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 7, "bases": 0, "doc": 3}, "cpdbench.examples.Example_Parameters.execute_esst_test": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 22, "bases": 0, "doc": 3}, "cpdbench.examples.Example_Parameters.calc_accuracy": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 33, "bases": 0, "doc": 3}, "cpdbench.examples.Example_Simple": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.examples.Example_Simple.cpdb": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 8, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.examples.Example_Simple.get_apple_dataset": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 7, "bases": 0, "doc": 3}, "cpdbench.examples.Example_Simple.get_bitcoin_dataset": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 7, "bases": 0, "doc": 3}, "cpdbench.examples.Example_Simple.execute_esst_test": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "cpdbench.examples.Example_Simple.calc_accuracy": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 22, "bases": 0, "doc": 3}, "cpdbench.examples.Example_VeryLargeDataset": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.examples.Example_VeryLargeDataset.cpdb": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 8, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.examples.Example_VeryLargeDataset.get_large_dataset": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 7, "bases": 0, "doc": 3}, "cpdbench.examples.Example_VeryLargeDataset.execute_algorithm": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 22, "bases": 0, "doc": 3}, "cpdbench.examples.Example_VeryLargeDataset.compute_metric": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 22, "bases": 0, "doc": 3}, "cpdbench.exception": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 14}, "cpdbench.exception.AlgorithmExecutionException": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 15}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 13, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.exception.CPDExecutionException": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.exception.CPDExecutionException.CPDExecutionException": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 18}, "cpdbench.exception.CPDExecutionException.CPDExecutionException.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 9, "bases": 0, "doc": 3}, "cpdbench.exception.ConfigurationException": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.exception.ConfigurationException.ConfigurationException": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 14}, "cpdbench.exception.ConfigurationException.ConfigurationException.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 10, "bases": 0, "doc": 3}, "cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 15, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 12}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 10, "bases": 0, "doc": 3}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 16, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.exception.DatasetFetchException": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.exception.DatasetFetchException.DatasetFetchException": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 12}, "cpdbench.exception.DatasetFetchException.DatasetFetchException.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 9, "bases": 0, "doc": 3}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 15}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 10, "bases": 0, "doc": 3}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 14, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 15}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 15, "bases": 0, "doc": 3}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 15, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.exception.DatasetFetchException.SignalLoadingException": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 15}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 10, "bases": 0, "doc": 3}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 15, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.exception.MetricExecutionException": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 16}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 22, "bases": 0, "doc": 3}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 15, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.exception.ResultSetInconsistentException": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 28}, "cpdbench.exception.UserParameterDoesNotExistException": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 23}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 22, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.exception.ValidationException": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.exception.ValidationException.ValidationException": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 11}, "cpdbench.exception.ValidationException.InputValidationException": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 15}, "cpdbench.exception.ValidationException.AlgorithmValidationException": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 12}, "cpdbench.exception.ValidationException.MetricValidationException": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 12}, "cpdbench.exception.ValidationException.DatasetValidationException": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 12}, "cpdbench.task": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 19}, "cpdbench.task.AlgorithmExecutionTask": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 35}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 25, "bases": 0, "doc": 67}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 21}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 63, "bases": 0, "doc": 19}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 63, "bases": 0, "doc": 18}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 23}, "cpdbench.task.DatasetFetchTask": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 35}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 25, "bases": 0, "doc": 67}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 21}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 52, "bases": 0, "doc": 19}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 18}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 23}, "cpdbench.task.MetricExecutionTask": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 4, "doc": 35}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 25, "bases": 0, "doc": 67}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 79, "bases": 0, "doc": 18}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 21}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 79, "bases": 0, "doc": 19}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 23}, "cpdbench.task.Task": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.task.Task.TaskType": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 12}, "cpdbench.task.Task.TaskType.DATASET_FETCH": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 8, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 8, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.task.Task.TaskType.METRIC_EXECUTION": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 8, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.task.Task.Task": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 35}, "cpdbench.task.Task.Task.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 30, "bases": 0, "doc": 67}, "cpdbench.task.Task.Task.execute": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 40, "bases": 0, "doc": 18}, "cpdbench.task.Task.Task.validate_task": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 21}, "cpdbench.task.Task.Task.validate_input": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 40, "bases": 0, "doc": 19}, "cpdbench.task.Task.Task.get_task_name": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 23}, "cpdbench.task.Task.Task.get_param_dict": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 22}, "cpdbench.task.TaskFactory": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.task.TaskFactory.TaskFactory": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 8}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 68, "bases": 0, "doc": 56}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 74, "bases": 0, "doc": 85}, "cpdbench.utils": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 21}, "cpdbench.utils.BenchConfig": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 50}, "cpdbench.utils.BenchConfig.logging_file_name": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 7, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.utils.BenchConfig.logging_level": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.utils.BenchConfig.logging_console_level": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.utils.BenchConfig.multiprocessing_enabled": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.utils.BenchConfig.result_file_name": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 7, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.utils.BenchConfig.get_user_config": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 25, "bases": 0, "doc": 16}, "cpdbench.utils.BenchConfig.get_complete_config": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 10, "bases": 0, "doc": 19}, "cpdbench.utils.BenchConfig.load_config": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 25, "bases": 0, "doc": 77}, "cpdbench.utils.Logger": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.utils.Logger.init_logger": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 7, "bases": 0, "doc": 3}, "cpdbench.utils.Logger.get_application_logger": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 15, "bases": 0, "doc": 3}, "cpdbench.utils.UserConfig": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.utils.UserConfig.UserConfig": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 102}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 15, "bases": 0, "doc": 30}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 40, "bases": 0, "doc": 58}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 51, "bases": 0, "doc": 102}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 25, "bases": 0, "doc": 57}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 25}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 40}, "cpdbench.utils.Utils": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "cpdbench.utils.Utils.get_name_of_function": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 45}}, "length": 209, "save": true}, "index": {"qualname": {"root": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.__init__": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.__init__": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.__init__": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.__init__": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.__init__": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}}, "df": 21, "c": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "d": {"2": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.file_path": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.dtype": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}}, "df": 7}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}}, "df": 5}}}}}}}}}}}}}}}}, "docs": {}, "df": 0, "b": {"docs": {"cpdbench.examples.Example_Parameters.cpdb": {"tf": 1}, "cpdbench.examples.Example_Simple.cpdb": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.cpdb": {"tf": 1}}, "df": 3, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.CPDBench.CPDBench": {"tf": 1}, "cpdbench.CPDBench.CPDBench.start": {"tf": 1}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.CPDBench.CPDBench.dataset": {"tf": 1}, "cpdbench.CPDBench.CPDBench.algorithm": {"tf": 1}, "cpdbench.CPDBench.CPDBench.metric": {"tf": 1}}, "df": 6}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.dataset.CPDDataset.CPDDataset": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}}, "df": 4, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1}}, "df": 10}}}}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDFullResult.CPDFullResult": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}}, "df": 4}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDResult.CPDResult": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}}, "df": 2}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDValidationResult.CPDValidationResult": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException.__init__": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "c": {"docs": {"cpdbench.examples.Example_Parameters.calc_accuracy": {"tf": 1}, "cpdbench.examples.Example_Simple.calc_accuracy": {"tf": 1}}, "df": 2}}}, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.examples.Example_VeryLargeDataset.compute_metric": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.utils.BenchConfig.get_user_config": {"tf": 1}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 4, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1}}, "df": 3}}}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.utils.BenchConfig.logging_console_level": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}}, "df": 3}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1}}, "df": 5}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}}, "df": 4, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.DatasetFetchException.SignalLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}}, "df": 1}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 10}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}}, "df": 4, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ValidationException.ValidationException": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.CPDBench.CPDBench.dataset": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}, "cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"tf": 1}, "cpdbench.examples.ExampleDatasets.dataset_get_apple_dataset": {"tf": 1.4142135623730951}, "cpdbench.examples.ExampleDatasets.dataset_get_bitcoin_dataset": {"tf": 1.4142135623730951}, "cpdbench.examples.Example_Parameters.get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Parameters.get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.get_large_dataset": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}, "cpdbench.task.Task.TaskType.DATASET_FETCH": {"tf": 1}}, "df": 14, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.__init__": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.logger": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.execute": {"tf": 1}}, "df": 4}}}}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.DatasetFetchException.DatasetFetchException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException.__init__": {"tf": 1}}, "df": 2}}}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1}}, "df": 6}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ValidationException.DatasetValidationException": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}}, "df": 6}}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.dtype": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {"cpdbench.CPDBench.CPDBench.algorithm": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.execute_algorithm": {"tf": 1}, "cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION": {"tf": 1}}, "df": 6, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.__init__": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1}}, "df": 3}}}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1}}, "df": 6}}}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ValidationException.AlgorithmValidationException": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 1}}}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}}, "df": 5}}, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}}, "df": 5}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.examples.ExampleAlgorithms.numpy_array_accesses": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.examples.ExampleAlgorithms.numpy_array_accesses": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.examples.Example_Parameters.calc_accuracy": {"tf": 1}, "cpdbench.examples.Example_Simple.calc_accuracy": {"tf": 1}}, "df": 3}}}}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.examples.ExampleDatasets.dataset_get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Parameters.get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.get_apple_dataset": {"tf": 1}}, "df": 3}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.utils.Logger.get_application_logger": {"tf": 1}}, "df": 1}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"cpdbench.CPDBench.CPDBench.metric": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.compute_metric": {"tf": 1}, "cpdbench.task.Task.TaskType.METRIC_EXECUTION": {"tf": 1}}, "df": 6, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.__init__": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1}}, "df": 3}}}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1}}, "df": 6}}}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ValidationException.MetricValidationException": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}}, "df": 2}}}}}}, "s": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 6}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.utils.BenchConfig.multiprocessing_enabled": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}}, "df": 4, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"tf": 1}}, "df": 4}}}}, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1}}, "df": 1}}}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.DatasetExecutor.DatasetExecutor.execute": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}, "cpdbench.examples.Example_Parameters.execute_esst_test": {"tf": 1}, "cpdbench.examples.Example_Simple.execute_esst_test": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.execute_algorithm": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}}, "df": 13}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION": {"tf": 1}, "cpdbench.task.Task.TaskType.METRIC_EXECUTION": {"tf": 1}}, "df": 2, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}}, "df": 2}}}}}}}}}}, "s": {"docs": {"cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 2}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}}, "df": 2}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}, "cpdbench.examples.Example_Parameters.execute_esst_test": {"tf": 1}, "cpdbench.examples.Example_Simple.execute_esst_test": {"tf": 1}}, "df": 3}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.utils.BenchConfig.multiprocessing_enabled": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.__init__": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.__init__": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.__init__": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.__init__": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.utils.Logger.init_logger": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}}, "df": 25}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}}, "df": 4, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ValidationException.InputValidationException": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}, "f": {"docs": {"cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}}, "df": 5, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}}, "df": 1, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1}}, "df": 1}}}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}, "cpdbench.utils.BenchConfig.result_file_name": {"tf": 1}}, "df": 7, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"tf": 1}, "cpdbench.examples.ExampleDatasets.dataset_get_apple_dataset": {"tf": 1}, "cpdbench.examples.ExampleDatasets.dataset_get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_Parameters.get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Parameters.get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.get_large_dataset": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.Task.Task.get_task_name": {"tf": 1}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 1}, "cpdbench.utils.BenchConfig.get_user_config": {"tf": 1}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1}, "cpdbench.utils.Logger.get_application_logger": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 33}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.DatasetExecutor.DatasetExecutor.logger": {"tf": 1}, "cpdbench.utils.Logger.init_logger": {"tf": 1}, "cpdbench.utils.Logger.get_application_logger": {"tf": 1}}, "df": 3}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.utils.BenchConfig.logging_file_name": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_level": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_console_level": {"tf": 1}}, "df": 3}}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}}, "df": 3}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.get_large_dataset": {"tf": 1}}, "df": 2}}}}, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.utils.BenchConfig.logging_level": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_console_level": {"tf": 1}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {"cpdbench.task.Task.Task.get_param_dict": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}}, "df": 4, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}}, "df": 2}}}}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.file_path": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}}, "df": 3}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.examples.Example_Parameters.execute_esst_test": {"tf": 1}, "cpdbench.examples.Example_Simple.execute_esst_test": {"tf": 1}}, "df": 2, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.TestrunType": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"tf": 1}}, "df": 3}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestrunController.TestrunController": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.get_task_name": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}}, "df": 14, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.task.Task.TaskType": {"tf": 1}, "cpdbench.task.Task.TaskType.DATASET_FETCH": {"tf": 1}, "cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION": {"tf": 1}, "cpdbench.task.Task.TaskType.METRIC_EXECUTION": {"tf": 1}}, "df": 4}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.task.TaskFactory.TaskFactory": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}}, "df": 3}}}}}}}, "s": {"docs": {"cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.examples.ExampleAlgorithms.numpy_array_accesses": {"tf": 1}}, "df": 1}}, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.Task.Task.get_task_name": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_file_name": {"tf": 1}, "cpdbench.utils.BenchConfig.result_file_name": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 7}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.file_path": {"tf": 1}, "cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_file_name": {"tf": 1}, "cpdbench.utils.BenchConfig.result_file_name": {"tf": 1}}, "df": 4}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.task.Task.TaskType.DATASET_FETCH": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 2}}}}}}}}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.examples.ExampleDatasets.dataset_get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_Parameters.get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.get_bitcoin_dataset": {"tf": 1}}, "df": 3}}}}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.utils.BenchConfig.get_user_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 3, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.__init__": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 7}}}}}}}}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {"cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 2}}}}, "fullname": {"root": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.__init__": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.__init__": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.__init__": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.__init__": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.__init__": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}}, "df": 21, "c": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "d": {"2": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.file_path": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.dtype": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1.4142135623730951}}, "df": 8}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.dataset.CPD2DNdarrayDataset": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.__init__": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1.4142135623730951}}, "df": 6}}}}}}}}}}}}}}}}, "docs": {}, "df": 0, "b": {"docs": {"cpdbench.examples.Example_Parameters.cpdb": {"tf": 1}, "cpdbench.examples.Example_Simple.cpdb": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.cpdb": {"tf": 1}}, "df": 3, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench": {"tf": 1}, "cpdbench.CPDBench": {"tf": 1.4142135623730951}, "cpdbench.CPDBench.CPDBench": {"tf": 1.7320508075688772}, "cpdbench.CPDBench.CPDBench.start": {"tf": 1.7320508075688772}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1.7320508075688772}, "cpdbench.CPDBench.CPDBench.dataset": {"tf": 1.7320508075688772}, "cpdbench.CPDBench.CPDBench.algorithm": {"tf": 1.7320508075688772}, "cpdbench.CPDBench.CPDBench.metric": {"tf": 1.7320508075688772}, "cpdbench.control": {"tf": 1}, "cpdbench.control.CPDDatasetResult": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1}, "cpdbench.control.CPDFullResult": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDResult": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.DatasetExecutor": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.__init__": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.logger": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.execute": {"tf": 1}, "cpdbench.control.ExecutionController": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.control.TestrunController": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.dataset": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.file_path": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.dtype": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.examples": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms.numpy_array_accesses": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}, "cpdbench.examples.ExampleDatasets": {"tf": 1}, "cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"tf": 1}, "cpdbench.examples.ExampleDatasets.dataset_get_apple_dataset": {"tf": 1}, "cpdbench.examples.ExampleDatasets.dataset_get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.ExampleMetrics": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.examples.Example_Parameters": {"tf": 1}, "cpdbench.examples.Example_Parameters.cpdb": {"tf": 1}, "cpdbench.examples.Example_Parameters.get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Parameters.get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_Parameters.execute_esst_test": {"tf": 1}, "cpdbench.examples.Example_Parameters.calc_accuracy": {"tf": 1}, "cpdbench.examples.Example_Simple": {"tf": 1}, "cpdbench.examples.Example_Simple.cpdb": {"tf": 1}, "cpdbench.examples.Example_Simple.get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.execute_esst_test": {"tf": 1}, "cpdbench.examples.Example_Simple.calc_accuracy": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.cpdb": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.get_large_dataset": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.execute_algorithm": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.compute_metric": {"tf": 1}, "cpdbench.exception": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.__init__": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.CPDExecutionException": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}, "cpdbench.exception.DatasetFetchException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}, "cpdbench.exception.MetricExecutionException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.__init__": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.__init__": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}, "cpdbench.exception.ValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.ValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.InputValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.AlgorithmValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.MetricValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.DatasetValidationException": {"tf": 1}, "cpdbench.task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.DatasetFetchTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1}, "cpdbench.task.MetricExecutionTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.Task": {"tf": 1}, "cpdbench.task.Task.TaskType": {"tf": 1}, "cpdbench.task.Task.TaskType.DATASET_FETCH": {"tf": 1}, "cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION": {"tf": 1}, "cpdbench.task.Task.TaskType.METRIC_EXECUTION": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.get_task_name": {"tf": 1}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 1}, "cpdbench.task.TaskFactory": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_file_name": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_level": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_console_level": {"tf": 1}, "cpdbench.utils.BenchConfig.multiprocessing_enabled": {"tf": 1}, "cpdbench.utils.BenchConfig.result_file_name": {"tf": 1}, "cpdbench.utils.BenchConfig.get_user_config": {"tf": 1}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.Logger": {"tf": 1}, "cpdbench.utils.Logger.init_logger": {"tf": 1}, "cpdbench.utils.Logger.get_application_logger": {"tf": 1}, "cpdbench.utils.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}, "cpdbench.utils.Utils": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 209}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.dataset.CPDDataset": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1.4142135623730951}}, "df": 5, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1.4142135623730951}}, "df": 15}}}}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDFullResult": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult": {"tf": 1.4142135623730951}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1.4142135623730951}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1.4142135623730951}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1.4142135623730951}}, "df": 5}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDResult": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult": {"tf": 1.4142135623730951}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1.4142135623730951}}, "df": 3}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDValidationResult": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult": {"tf": 1.4142135623730951}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1.4142135623730951}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1.4142135623730951}}, "df": 4}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.CPDExecutionException": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1.4142135623730951}, "cpdbench.exception.CPDExecutionException.CPDExecutionException.__init__": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.control": {"tf": 1}, "cpdbench.control.CPDDatasetResult": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1}, "cpdbench.control.CPDFullResult": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDResult": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.DatasetExecutor": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.__init__": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.logger": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.execute": {"tf": 1}, "cpdbench.control.ExecutionController": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.control.TestrunController": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}}, "df": 50}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.utils.BenchConfig.get_user_config": {"tf": 1}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 4, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ConfigurationException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException": {"tf": 1.4142135623730951}, "cpdbench.exception.ConfigurationException.ConfigurationException.__init__": {"tf": 1.4142135623730951}, "cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1.4142135623730951}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}}, "df": 7}}}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.utils.BenchConfig.logging_console_level": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.examples.Example_VeryLargeDataset.compute_metric": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "c": {"docs": {"cpdbench.examples.Example_Parameters.calc_accuracy": {"tf": 1}, "cpdbench.examples.Example_Simple.calc_accuracy": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}}, "df": 3}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1}}, "df": 5}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}}, "df": 4, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.DatasetFetchException.SignalLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.examples.Example_Simple": {"tf": 1}, "cpdbench.examples.Example_Simple.cpdb": {"tf": 1}, "cpdbench.examples.Example_Simple.get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.execute_esst_test": {"tf": 1}, "cpdbench.examples.Example_Simple.calc_accuracy": {"tf": 1}}, "df": 6}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 10}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}}, "df": 4, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.ValidationRunController": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1.4142135623730951}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.ValidationException": {"tf": 1.4142135623730951}, "cpdbench.exception.ValidationException.InputValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.AlgorithmValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.MetricValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.DatasetValidationException": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.examples.Example_VeryLargeDataset": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.cpdb": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.get_large_dataset": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.execute_algorithm": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.compute_metric": {"tf": 1}}, "df": 5}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.CPDBench.CPDBench.dataset": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}, "cpdbench.dataset": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.file_path": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.dtype": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"tf": 1}, "cpdbench.examples.ExampleDatasets.dataset_get_apple_dataset": {"tf": 1.4142135623730951}, "cpdbench.examples.ExampleDatasets.dataset_get_bitcoin_dataset": {"tf": 1.4142135623730951}, "cpdbench.examples.Example_Parameters.get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Parameters.get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.get_large_dataset": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}, "cpdbench.task.Task.TaskType.DATASET_FETCH": {"tf": 1}}, "df": 34, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.DatasetExecutor": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1.4142135623730951}, "cpdbench.control.DatasetExecutor.DatasetExecutor.__init__": {"tf": 1.4142135623730951}, "cpdbench.control.DatasetExecutor.DatasetExecutor.logger": {"tf": 1.4142135623730951}, "cpdbench.control.DatasetExecutor.DatasetExecutor.execute": {"tf": 1.4142135623730951}}, "df": 5}}}}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.DatasetFetchException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException": {"tf": 1.4142135623730951}, "cpdbench.exception.DatasetFetchException.DatasetFetchException.__init__": {"tf": 1.4142135623730951}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}}, "df": 12}}}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"cpdbench.task.DatasetFetchTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1.4142135623730951}}, "df": 7}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ValidationException.DatasetValidationException": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}}, "df": 6}}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.dtype": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {"cpdbench.CPDBench.CPDBench.algorithm": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.execute_algorithm": {"tf": 1}, "cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION": {"tf": 1}}, "df": 6, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1.4142135623730951}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.__init__": {"tf": 1.4142135623730951}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1.4142135623730951}}, "df": 4}}}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"cpdbench.task.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1.4142135623730951}}, "df": 7}}}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ValidationException.AlgorithmValidationException": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 1}}}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}}, "df": 5}}, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}}, "df": 5}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.examples.ExampleAlgorithms.numpy_array_accesses": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.examples.ExampleAlgorithms.numpy_array_accesses": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.examples.Example_Parameters.calc_accuracy": {"tf": 1}, "cpdbench.examples.Example_Simple.calc_accuracy": {"tf": 1}}, "df": 3}}}}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.examples.ExampleDatasets.dataset_get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Parameters.get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.get_apple_dataset": {"tf": 1}}, "df": 3}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.utils.Logger.get_application_logger": {"tf": 1}}, "df": 1}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"cpdbench.CPDBench.CPDBench.metric": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.compute_metric": {"tf": 1}, "cpdbench.task.Task.TaskType.METRIC_EXECUTION": {"tf": 1}}, "df": 6, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.MetricExecutionException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1.4142135623730951}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.__init__": {"tf": 1.4142135623730951}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1.4142135623730951}}, "df": 4}}}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"cpdbench.task.MetricExecutionTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1.4142135623730951}}, "df": 7}}}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ValidationException.MetricValidationException": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}}, "df": 2}}}}}}, "s": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 6}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.utils.BenchConfig.multiprocessing_enabled": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}}, "df": 4, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"tf": 1}}, "df": 4}}}}, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1}}, "df": 1}}}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.DatasetExecutor.DatasetExecutor.execute": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}, "cpdbench.examples.Example_Parameters.execute_esst_test": {"tf": 1}, "cpdbench.examples.Example_Simple.execute_esst_test": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.execute_algorithm": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}}, "df": 13}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION": {"tf": 1}, "cpdbench.task.Task.TaskType.METRIC_EXECUTION": {"tf": 1}}, "df": 2, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.ExecutionController": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController": {"tf": 1.4142135623730951}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}}}}, "s": {"docs": {"cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 2}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.examples.Example_Parameters": {"tf": 1}, "cpdbench.examples.Example_Parameters.cpdb": {"tf": 1}, "cpdbench.examples.Example_Parameters.get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Parameters.get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_Parameters.execute_esst_test": {"tf": 1}, "cpdbench.examples.Example_Parameters.calc_accuracy": {"tf": 1}, "cpdbench.examples.Example_Simple": {"tf": 1}, "cpdbench.examples.Example_Simple.cpdb": {"tf": 1}, "cpdbench.examples.Example_Simple.get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.execute_esst_test": {"tf": 1}, "cpdbench.examples.Example_Simple.calc_accuracy": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.cpdb": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.get_large_dataset": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.execute_algorithm": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.compute_metric": {"tf": 1}}, "df": 17, "s": {"docs": {"cpdbench.examples": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms.numpy_array_accesses": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}, "cpdbench.examples.ExampleDatasets": {"tf": 1}, "cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"tf": 1}, "cpdbench.examples.ExampleDatasets.dataset_get_apple_dataset": {"tf": 1}, "cpdbench.examples.ExampleDatasets.dataset_get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.ExampleMetrics": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.examples.Example_Parameters": {"tf": 1}, "cpdbench.examples.Example_Parameters.cpdb": {"tf": 1}, "cpdbench.examples.Example_Parameters.get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Parameters.get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_Parameters.execute_esst_test": {"tf": 1}, "cpdbench.examples.Example_Parameters.calc_accuracy": {"tf": 1}, "cpdbench.examples.Example_Simple": {"tf": 1}, "cpdbench.examples.Example_Simple.cpdb": {"tf": 1}, "cpdbench.examples.Example_Simple.get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.execute_esst_test": {"tf": 1}, "cpdbench.examples.Example_Simple.calc_accuracy": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.cpdb": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.get_large_dataset": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.execute_algorithm": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.compute_metric": {"tf": 1}}, "df": 27}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.examples.ExampleAlgorithms": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms.numpy_array_accesses": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}}, "df": 3}}}}}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.examples.ExampleDatasets": {"tf": 1}, "cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"tf": 1}, "cpdbench.examples.ExampleDatasets.dataset_get_apple_dataset": {"tf": 1}, "cpdbench.examples.ExampleDatasets.dataset_get_bitcoin_dataset": {"tf": 1}}, "df": 4}}}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.examples.ExampleMetrics": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 2}}}}}}}}}}}}, "c": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.__init__": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.CPDExecutionException": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}, "cpdbench.exception.DatasetFetchException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}, "cpdbench.exception.MetricExecutionException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.__init__": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.__init__": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}, "cpdbench.exception.ValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.ValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.InputValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.AlgorithmValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.MetricValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.DatasetValidationException": {"tf": 1}}, "df": 43}}}}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}, "cpdbench.examples.Example_Parameters.execute_esst_test": {"tf": 1}, "cpdbench.examples.Example_Simple.execute_esst_test": {"tf": 1}}, "df": 3}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.utils.BenchConfig.multiprocessing_enabled": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.__init__": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.__init__": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.__init__": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.__init__": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.utils.Logger.init_logger": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}}, "df": 25}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}}, "df": 4, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ValidationException.InputValidationException": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}, "f": {"docs": {"cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}}, "df": 5, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}}, "df": 1, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1}}, "df": 1}}}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}, "cpdbench.utils.BenchConfig.result_file_name": {"tf": 1}}, "df": 7, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ResultSetInconsistentException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"tf": 1}, "cpdbench.examples.ExampleDatasets.dataset_get_apple_dataset": {"tf": 1}, "cpdbench.examples.ExampleDatasets.dataset_get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_Parameters.get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Parameters.get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.get_large_dataset": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.Task.Task.get_task_name": {"tf": 1}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 1}, "cpdbench.utils.BenchConfig.get_user_config": {"tf": 1}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1}, "cpdbench.utils.Logger.get_application_logger": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 33}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.DatasetExecutor.DatasetExecutor.logger": {"tf": 1}, "cpdbench.utils.Logger": {"tf": 1}, "cpdbench.utils.Logger.init_logger": {"tf": 1.4142135623730951}, "cpdbench.utils.Logger.get_application_logger": {"tf": 1.4142135623730951}}, "df": 4}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.utils.BenchConfig.logging_file_name": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_level": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_console_level": {"tf": 1}}, "df": 3}}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}}, "df": 3}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.get_large_dataset": {"tf": 1}}, "df": 2}}}}, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.utils.BenchConfig.logging_level": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_console_level": {"tf": 1}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {"cpdbench.task.Task.Task.get_param_dict": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}}, "df": 4, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1}, "cpdbench.examples.Example_Parameters": {"tf": 1}, "cpdbench.examples.Example_Parameters.cpdb": {"tf": 1}, "cpdbench.examples.Example_Parameters.get_apple_dataset": {"tf": 1}, "cpdbench.examples.Example_Parameters.get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_Parameters.execute_esst_test": {"tf": 1}, "cpdbench.examples.Example_Parameters.calc_accuracy": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}}, "df": 8}}}}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.file_path": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}}, "df": 3}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.examples.Example_Parameters.execute_esst_test": {"tf": 1}, "cpdbench.examples.Example_Simple.execute_esst_test": {"tf": 1}}, "df": 2, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestbenchController": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1.4142135623730951}}, "df": 8}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.TestrunType": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"tf": 1}}, "df": 3}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestrunController": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1.4142135623730951}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}}}}}}}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"cpdbench.task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1.4142135623730951}, "cpdbench.task.Task": {"tf": 1.4142135623730951}, "cpdbench.task.Task.TaskType": {"tf": 1.4142135623730951}, "cpdbench.task.Task.TaskType.DATASET_FETCH": {"tf": 1.4142135623730951}, "cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION": {"tf": 1.4142135623730951}, "cpdbench.task.Task.TaskType.METRIC_EXECUTION": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task": {"tf": 1.7320508075688772}, "cpdbench.task.Task.Task.__init__": {"tf": 1.7320508075688772}, "cpdbench.task.Task.Task.execute": {"tf": 1.7320508075688772}, "cpdbench.task.Task.Task.validate_task": {"tf": 2}, "cpdbench.task.Task.Task.validate_input": {"tf": 1.7320508075688772}, "cpdbench.task.Task.Task.get_task_name": {"tf": 2}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 1.7320508075688772}, "cpdbench.task.TaskFactory": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1.4142135623730951}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}}, "df": 38, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.task.Task.TaskType": {"tf": 1}, "cpdbench.task.Task.TaskType.DATASET_FETCH": {"tf": 1}, "cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION": {"tf": 1}, "cpdbench.task.Task.TaskType.METRIC_EXECUTION": {"tf": 1}}, "df": 4}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.task.TaskFactory": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory": {"tf": 1.4142135623730951}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1.4142135623730951}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1.4142135623730951}}, "df": 4}}}}}}}, "s": {"docs": {"cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.examples.ExampleAlgorithms.numpy_array_accesses": {"tf": 1}}, "df": 1}}, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.Task.Task.get_task_name": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_file_name": {"tf": 1}, "cpdbench.utils.BenchConfig.result_file_name": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 7}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.file_path": {"tf": 1}, "cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_file_name": {"tf": 1}, "cpdbench.utils.BenchConfig.result_file_name": {"tf": 1}}, "df": 4}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.task.Task.TaskType.DATASET_FETCH": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 2}}}}}}}}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.examples.ExampleDatasets.dataset_get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_Parameters.get_bitcoin_dataset": {"tf": 1}, "cpdbench.examples.Example_Simple.get_bitcoin_dataset": {"tf": 1}}, "df": 3}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_file_name": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_level": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_console_level": {"tf": 1}, "cpdbench.utils.BenchConfig.multiprocessing_enabled": {"tf": 1}, "cpdbench.utils.BenchConfig.result_file_name": {"tf": 1}, "cpdbench.utils.BenchConfig.get_user_config": {"tf": 1}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}}, "df": 9}}}}}}}}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.utils.BenchConfig.get_user_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 3, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1.4142135623730951}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.__init__": {"tf": 1.4142135623730951}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1.4142135623730951}}, "df": 4}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.utils.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1.4142135623730951}}, "df": 8}}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.utils": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_file_name": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_level": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_console_level": {"tf": 1}, "cpdbench.utils.BenchConfig.multiprocessing_enabled": {"tf": 1}, "cpdbench.utils.BenchConfig.result_file_name": {"tf": 1}, "cpdbench.utils.BenchConfig.get_user_config": {"tf": 1}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.Logger": {"tf": 1}, "cpdbench.utils.Logger.init_logger": {"tf": 1}, "cpdbench.utils.Logger.get_application_logger": {"tf": 1}, "cpdbench.utils.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}, "cpdbench.utils.Utils": {"tf": 1.4142135623730951}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1.4142135623730951}}, "df": 23}}}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {"cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 2}}}}, "annotation": {"root": {"docs": {"cpdbench.utils.BenchConfig.logging_file_name": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_level": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_console_level": {"tf": 1}, "cpdbench.utils.BenchConfig.result_file_name": {"tf": 1}}, "df": 4, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.utils.BenchConfig.logging_file_name": {"tf": 1}, "cpdbench.utils.BenchConfig.result_file_name": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.utils.BenchConfig.logging_level": {"tf": 1}, "cpdbench.utils.BenchConfig.logging_console_level": {"tf": 1}}, "df": 2}}}}}, "default_value": {"root": {"0": {"docs": {"cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 8}, "1": {"docs": {"cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}, "cpdbench.task.Task.TaskType.DATASET_FETCH": {"tf": 1}}, "df": 6}, "2": {"0": {"docs": {"cpdbench.utils.BenchConfig.logging_level": {"tf": 1}}, "df": 1}, "docs": {"cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1}, "cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION": {"tf": 1}}, "df": 3}, "3": {"docs": {"cpdbench.task.Task.TaskType.METRIC_EXECUTION": {"tf": 1}}, "df": 1}, "4": {"0": {"docs": {"cpdbench.utils.BenchConfig.logging_console_level": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {"cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"tf": 1.4142135623730951}, "cpdbench.examples.Example_Parameters.cpdb": {"tf": 1.4142135623730951}, "cpdbench.examples.Example_Simple.cpdb": {"tf": 1.4142135623730951}, "cpdbench.examples.Example_VeryLargeDataset.cpdb": {"tf": 1.4142135623730951}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1.4142135623730951}, "cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1.4142135623730951}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1.4142135623730951}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1.4142135623730951}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1.4142135623730951}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1.4142135623730951}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1.4142135623730951}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1.4142135623730951}, "cpdbench.task.Task.TaskType.DATASET_FETCH": {"tf": 1.4142135623730951}, "cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION": {"tf": 1.4142135623730951}, "cpdbench.task.Task.TaskType.METRIC_EXECUTION": {"tf": 1.4142135623730951}, "cpdbench.utils.BenchConfig.logging_file_name": {"tf": 1.4142135623730951}, "cpdbench.utils.BenchConfig.result_file_name": {"tf": 1.4142135623730951}}, "df": 21, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"tf": 1}, "cpdbench.examples.Example_Parameters.cpdb": {"tf": 1}, "cpdbench.examples.Example_Simple.cpdb": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.cpdb": {"tf": 1}, "cpdbench.task.Task.TaskType.DATASET_FETCH": {"tf": 1}, "cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION": {"tf": 1}, "cpdbench.task.Task.TaskType.METRIC_EXECUTION": {"tf": 1}}, "df": 11}, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}}, "df": 2}}}}}, "g": {"docs": {"cpdbench.utils.BenchConfig.logging_file_name": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"tf": 1.4142135623730951}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1}}, "df": 9, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"tf": 1}}, "df": 3}}}}}}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1}}, "df": 2}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION": {"tf": 1}, "cpdbench.task.Task.TaskType.METRIC_EXECUTION": {"tf": 1}}, "df": 2}}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 2}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"tf": 1.4142135623730951}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1}, "cpdbench.task.Task.TaskType.DATASET_FETCH": {"tf": 1}}, "df": 4}}}}}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}}, "df": 2}}}}}}, "o": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 2}}}}, "x": {"2": {"7": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"tf": 1.4142135623730951}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1.4142135623730951}, "cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1.4142135623730951}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1.4142135623730951}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1.4142135623730951}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1.4142135623730951}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1.4142135623730951}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1.4142135623730951}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1.4142135623730951}, "cpdbench.utils.BenchConfig.logging_file_name": {"tf": 1.4142135623730951}, "cpdbench.utils.BenchConfig.result_file_name": {"tf": 1.4142135623730951}}, "df": 13}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "g": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"tf": 1}, "cpdbench.examples.Example_Parameters.cpdb": {"tf": 1}, "cpdbench.examples.Example_Simple.cpdb": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.cpdb": {"tf": 1}, "cpdbench.task.Task.TaskType.DATASET_FETCH": {"tf": 1}, "cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION": {"tf": 1}, "cpdbench.task.Task.TaskType.METRIC_EXECUTION": {"tf": 1}}, "df": 11}, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"tf": 1.4142135623730951}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1}, "cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION": {"tf": 1}}, "df": 4}}}}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"tf": 1.4142135623730951}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1}, "cpdbench.task.Task.TaskType.METRIC_EXECUTION": {"tf": 1}}, "df": 3}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"tf": 1}}, "df": 2}}}}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1.4142135623730951}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1.4142135623730951}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1.4142135623730951}}, "df": 6}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.task.Task.TaskType.DATASET_FETCH": {"tf": 1}, "cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION": {"tf": 1}, "cpdbench.task.Task.TaskType.METRIC_EXECUTION": {"tf": 1}}, "df": 3}}}}}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.utils.BenchConfig.logging_file_name": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.utils.BenchConfig.multiprocessing_enabled": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"tf": 1}}, "df": 2, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.utils.BenchConfig.result_file_name": {"tf": 1}}, "df": 1}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.examples.Example_Parameters.cpdb": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_Simple.cpdb": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_VeryLargeDataset.cpdb": {"tf": 1.7320508075688772}, "cpdbench.utils.BenchConfig.logging_file_name": {"tf": 1}, "cpdbench.utils.BenchConfig.result_file_name": {"tf": 1}}, "df": 5}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}}, "df": 3}}}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1.4142135623730951}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 2, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.examples.Example_Parameters.cpdb": {"tf": 1}, "cpdbench.examples.Example_Simple.cpdb": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.cpdb": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}}, "df": 4}}}}}, "n": {"docs": {"cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1}}, "df": 2}, "f": {"docs": {"cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}}, "df": 2}}, "w": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1}}, "df": 5}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 2, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {"cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 1}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 3}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 2}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}}, "df": 3}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.task.Task.TaskType.DATASET_FETCH": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}}, "df": 2}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1}}, "df": 1}}}}}}, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1}}, "df": 1}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.utils.BenchConfig.result_file_name": {"tf": 1}}, "df": 1}}}}}}, "signature": {"root": {"0": {"docs": {"cpdbench.task.Task.Task.__init__": {"tf": 1}}, "df": 1}, "3": {"9": {"docs": {"cpdbench.CPDBench.CPDBench.validate": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 2}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 2}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1.4142135623730951}}, "df": 4}, "docs": {}, "df": 0}, "docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 5.0990195135927845}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 5.291502622129181}, "cpdbench.CPDBench.CPDBench.dataset": {"tf": 3.7416573867739413}, "cpdbench.CPDBench.CPDBench.algorithm": {"tf": 3.7416573867739413}, "cpdbench.CPDBench.CPDBench.metric": {"tf": 3.7416573867739413}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 6.324555320336759}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 4.47213595499958}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 7}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 7}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 8.54400374531753}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 3.4641016151377544}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 3.4641016151377544}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 3.4641016151377544}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 3.4641016151377544}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 5.291502622129181}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 5.830951894845301}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 3.4641016151377544}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 3.4641016151377544}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 6}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 3.4641016151377544}, "cpdbench.control.DatasetExecutor.DatasetExecutor.__init__": {"tf": 4.47213595499958}, "cpdbench.control.DatasetExecutor.DatasetExecutor.execute": {"tf": 3.1622776601683795}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 5.656854249492381}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 3.7416573867739413}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 7.810249675906654}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 5.656854249492381}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 5.656854249492381}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 5.291502622129181}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 3.4641016151377544}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 5.385164807134504}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 5.385164807134504}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.__init__": {"tf": 3.4641016151377544}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 5.385164807134504}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 3.4641016151377544}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 5.385164807134504}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 3.4641016151377544}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 5.385164807134504}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 5.385164807134504}, "cpdbench.examples.ExampleAlgorithms.numpy_array_accesses": {"tf": 3.7416573867739413}, "cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 3.7416573867739413}, "cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"tf": 2.6457513110645907}, "cpdbench.examples.ExampleDatasets.dataset_get_apple_dataset": {"tf": 2.6457513110645907}, "cpdbench.examples.ExampleDatasets.dataset_get_bitcoin_dataset": {"tf": 2.6457513110645907}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 5.196152422706632}, "cpdbench.examples.Example_Parameters.get_apple_dataset": {"tf": 2.6457513110645907}, "cpdbench.examples.Example_Parameters.get_bitcoin_dataset": {"tf": 2.6457513110645907}, "cpdbench.examples.Example_Parameters.execute_esst_test": {"tf": 4.358898943540674}, "cpdbench.examples.Example_Parameters.calc_accuracy": {"tf": 5.196152422706632}, "cpdbench.examples.Example_Simple.get_apple_dataset": {"tf": 2.6457513110645907}, "cpdbench.examples.Example_Simple.get_bitcoin_dataset": {"tf": 2.6457513110645907}, "cpdbench.examples.Example_Simple.execute_esst_test": {"tf": 3.1622776601683795}, "cpdbench.examples.Example_Simple.calc_accuracy": {"tf": 4.242640687119285}, "cpdbench.examples.Example_VeryLargeDataset.get_large_dataset": {"tf": 2.6457513110645907}, "cpdbench.examples.Example_VeryLargeDataset.execute_algorithm": {"tf": 4.358898943540674}, "cpdbench.examples.Example_VeryLargeDataset.compute_metric": {"tf": 4.242640687119285}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.__init__": {"tf": 3.4641016151377544}, "cpdbench.exception.CPDExecutionException.CPDExecutionException.__init__": {"tf": 2.8284271247461903}, "cpdbench.exception.ConfigurationException.ConfigurationException.__init__": {"tf": 2.8284271247461903}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.__init__": {"tf": 2.8284271247461903}, "cpdbench.exception.DatasetFetchException.DatasetFetchException.__init__": {"tf": 2.8284271247461903}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.__init__": {"tf": 2.8284271247461903}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.__init__": {"tf": 3.4641016151377544}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.__init__": {"tf": 2.8284271247461903}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.__init__": {"tf": 4}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.__init__": {"tf": 3.4641016151377544}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 4.47213595499958}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 3.4641016151377544}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 7.211102550927978}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 7.211102550927978}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 3.4641016151377544}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 4.47213595499958}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 3.4641016151377544}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 6}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 5.385164807134504}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 3.4641016151377544}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 4.47213595499958}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 8}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 3.4641016151377544}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 8}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 3.4641016151377544}, "cpdbench.task.Task.Task.__init__": {"tf": 4.898979485566356}, "cpdbench.task.Task.Task.execute": {"tf": 5.656854249492381}, "cpdbench.task.Task.Task.validate_task": {"tf": 3.4641016151377544}, "cpdbench.task.Task.Task.validate_input": {"tf": 5.656854249492381}, "cpdbench.task.Task.Task.get_task_name": {"tf": 3.4641016151377544}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 3.4641016151377544}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 7.416198487095663}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 7.745966692414834}, "cpdbench.utils.BenchConfig.get_user_config": {"tf": 4.58257569495584}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 3}, "cpdbench.utils.BenchConfig.load_config": {"tf": 4.242640687119285}, "cpdbench.utils.Logger.init_logger": {"tf": 2.6457513110645907}, "cpdbench.utils.Logger.get_application_logger": {"tf": 3.605551275463989}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 3.4641016151377544}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 5.656854249492381}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 6.324555320336759}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 4.47213595499958}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 3.4641016151377544}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 3.4641016151377544}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 4}}, "df": 100, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "f": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.CPDBench.CPDBench.dataset": {"tf": 1}, "cpdbench.CPDBench.CPDBench.algorithm": {"tf": 1}, "cpdbench.CPDBench.CPDBench.metric": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.execute": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.get_task_name": {"tf": 1}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 56}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.Task.Task.get_task_name": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 13}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}}, "df": 1, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.examples.Example_Parameters.calc_accuracy": {"tf": 1}, "cpdbench.examples.Example_Simple.calc_accuracy": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}}, "df": 6}}}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}, "cpdbench.examples.Example_Parameters.execute_esst_test": {"tf": 1}, "cpdbench.examples.Example_Simple.execute_esst_test": {"tf": 1}}, "df": 3}}}}, "z": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.examples.Example_Parameters.calc_accuracy": {"tf": 1}}, "df": 2}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1.4142135623730951}, "cpdbench.exception.ConfigurationException.ConfigurationException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.__init__": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1.4142135623730951}}, "df": 5}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.examples.Example_VeryLargeDataset.compute_metric": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}}, "df": 6}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}}, "df": 4}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1.7320508075688772}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1.7320508075688772}}, "df": 4}}}}}}}}}}, "p": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1.4142135623730951}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1.4142135623730951}, "cpdbench.utils.BenchConfig.get_user_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}}, "df": 14}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}}, "df": 2, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1.4142135623730951}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1.4142135623730951}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 3}}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}}, "df": 4}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.CPDBench.CPDBench.dataset": {"tf": 1}, "cpdbench.CPDBench.CPDBench.algorithm": {"tf": 1}, "cpdbench.CPDBench.CPDBench.metric": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.__init__": {"tf": 1.4142135623730951}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.__init__": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.__init__": {"tf": 1.7320508075688772}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.__init__": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 18}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}}, "df": 5}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.exception.DatasetFetchException.FeatureLoadingException.__init__": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}}, "df": 2}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1.4142135623730951}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1.7320508075688772}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 21}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}}, "df": 9}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}}, "df": 8}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.__init__": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 3}}}}, "y": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}}, "df": 2}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}}, "df": 2, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.__init__": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms.numpy_array_accesses": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.execute_algorithm": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.__init__": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}}, "df": 12, "s": {"docs": {"cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}}, "df": 3}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 1}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}}, "df": 16}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1.7320508075688772}, "cpdbench.control.DatasetExecutor.DatasetExecutor.__init__": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 2.449489742783178}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 2.449489742783178}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.7320508075688772}}, "df": 6, "s": {"docs": {"cpdbench.control.DatasetExecutor.DatasetExecutor.__init__": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}}, "df": 2}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}}, "df": 4}}}}}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}}, "df": 5}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}}, "df": 1}}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.examples.Example_Parameters.calc_accuracy": {"tf": 1}, "cpdbench.examples.Example_Simple.calc_accuracy": {"tf": 1}}, "df": 3, "s": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.__init__": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.compute_metric": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}}, "df": 5}}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}}, "df": 8}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.__init__": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.__init__": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.__init__": {"tf": 1}}, "df": 6, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}}, "df": 4}}}}}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.__init__": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms.numpy_array_accesses": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.execute_algorithm": {"tf": 1}}, "df": 3}}}, "g": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}}, "df": 3}}}, "b": {"docs": {}, "df": 0, "c": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1.7320508075688772}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1.7320508075688772}}, "df": 4}}, "n": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.task.Task.Task.execute": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}}, "df": 2}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1.7320508075688772}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 2}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1.7320508075688772}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}}, "df": 15}}}, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.DatasetExecutor.DatasetExecutor.__init__": {"tf": 1}, "cpdbench.utils.Logger.get_application_logger": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.utils.Logger.get_application_logger": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}, "cpdbench.examples.Example_Parameters.execute_esst_test": {"tf": 1}}, "df": 2}}}}}, "t": {"docs": {"cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}}, "df": 4}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.__init__": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.__init__": {"tf": 1}}, "df": 4, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}}, "df": 4}}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}}, "df": 3}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.exception.CPDExecutionException.CPDExecutionException.__init__": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException.__init__": {"tf": 1}}, "df": 2}}}}}}, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}}, "df": 2}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}}, "df": 3}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}}, "df": 1}}}}, "f": {"docs": {"cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.task.Task.Task.execute": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}}, "df": 2, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms.numpy_array_accesses": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.examples.Example_Parameters.calc_accuracy": {"tf": 1}, "cpdbench.examples.Example_Simple.calc_accuracy": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.execute_algorithm": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.compute_metric": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}}, "df": 9}}}}}, "t": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}}, "df": 7}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1.7320508075688772}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1.7320508075688772}}, "df": 4}}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {"cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "j": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {"cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.__init__": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 7, "s": {"docs": {"cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}}, "df": 1}}}}}, "y": {"docs": {"cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}}, "df": 2}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.__init__": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.examples.Example_Parameters.calc_accuracy": {"tf": 1}, "cpdbench.examples.Example_Simple.calc_accuracy": {"tf": 1}, "cpdbench.examples.Example_VeryLargeDataset.compute_metric": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}}, "df": 8}}}}}, "t": {"docs": {"cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}}, "df": 4}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.examples.Example_Parameters.execute_esst_test": {"tf": 1}, "cpdbench.examples.Example_Parameters.calc_accuracy": {"tf": 1}}, "df": 4}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationException.__init__": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.__init__": {"tf": 1}}, "df": 2}}}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}}, "df": 1, "s": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.utils.BenchConfig.get_user_config": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.utils.BenchConfig.get_user_config": {"tf": 1}}, "df": 1}}}}}, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.task.Task.Task.execute": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}}, "df": 2}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 2}}}}}}, "bases": {"root": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.exception.ValidationException.ValidationException": {"tf": 1}}, "df": 7}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.TestrunType": {"tf": 1.4142135623730951}, "cpdbench.task.Task.TaskType": {"tf": 1.4142135623730951}}, "df": 3}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1}}}}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestrunController.TestrunController": {"tf": 1.4142135623730951}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.exception.ValidationException.ValidationException": {"tf": 1}}, "df": 9}}}}}}}}}, "c": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.control.CPDFullResult.CPDFullResult": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}}, "df": 12}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDFullResult.CPDFullResult": {"tf": 1.4142135623730951}, "cpdbench.control.CPDValidationResult.CPDValidationResult": {"tf": 1.4142135623730951}}, "df": 2}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1.4142135623730951}, "cpdbench.exception.DatasetFetchException.DatasetFetchException": {"tf": 1.4142135623730951}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.control.CPDFullResult.CPDFullResult": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}}, "df": 4}}}}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "c": {"docs": {"cpdbench.control.CPDResult.CPDResult": {"tf": 1.4142135623730951}, "cpdbench.control.ExecutionController.ExecutionController": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPDDataset.CPDDataset": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task": {"tf": 1.4142135623730951}}, "df": 4}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset": {"tf": 1}}, "df": 2, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.ValidationException.InputValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.AlgorithmValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.MetricValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.DatasetValidationException": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1.7320508075688772}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1.7320508075688772}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1.7320508075688772}}, "df": 3}}}}}}, "doc": {"root": {"2": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}}, "df": 6}}, "docs": {"cpdbench": {"tf": 1.7320508075688772}, "cpdbench.CPDBench": {"tf": 1.7320508075688772}, "cpdbench.CPDBench.CPDBench": {"tf": 1.4142135623730951}, "cpdbench.CPDBench.CPDBench.start": {"tf": 3.605551275463989}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 3.7416573867739413}, "cpdbench.CPDBench.CPDBench.dataset": {"tf": 1.4142135623730951}, "cpdbench.CPDBench.CPDBench.algorithm": {"tf": 1.4142135623730951}, "cpdbench.CPDBench.CPDBench.metric": {"tf": 1.4142135623730951}, "cpdbench.control": {"tf": 1.7320508075688772}, "cpdbench.control.CPDDatasetResult": {"tf": 1.7320508075688772}, "cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.ErrorType.DATASET_ERROR": {"tf": 1.7320508075688772}, "cpdbench.control.CPDDatasetResult.ErrorType.ALGORITHM_ERROR": {"tf": 1.7320508075688772}, "cpdbench.control.CPDDatasetResult.ErrorType.METRIC_ERROR": {"tf": 1.7320508075688772}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 4.47213595499958}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 3.605551275463989}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 5}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 5}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 5}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1.4142135623730951}, "cpdbench.control.CPDFullResult": {"tf": 1.7320508075688772}, "cpdbench.control.CPDFullResult.CPDFullResult": {"tf": 1.4142135623730951}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 4.47213595499958}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 3.4641016151377544}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 3.1622776601683795}, "cpdbench.control.CPDResult": {"tf": 1.7320508075688772}, "cpdbench.control.CPDResult.CPDResult": {"tf": 1.4142135623730951}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.control.CPDValidationResult": {"tf": 1.7320508075688772}, "cpdbench.control.CPDValidationResult.CPDValidationResult": {"tf": 1.7320508075688772}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 4.898979485566356}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 3.1622776601683795}, "cpdbench.control.DatasetExecutor": {"tf": 1.7320508075688772}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1.7320508075688772}, "cpdbench.control.DatasetExecutor.DatasetExecutor.__init__": {"tf": 1.7320508075688772}, "cpdbench.control.DatasetExecutor.DatasetExecutor.logger": {"tf": 1.7320508075688772}, "cpdbench.control.DatasetExecutor.DatasetExecutor.execute": {"tf": 1.7320508075688772}, "cpdbench.control.ExecutionController": {"tf": 1.7320508075688772}, "cpdbench.control.ExecutionController.ExecutionController": {"tf": 1.7320508075688772}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 4.69041575982343}, "cpdbench.control.TestbenchController": {"tf": 1.7320508075688772}, "cpdbench.control.TestbenchController.TestrunType": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.TestrunType.NORMAL_RUN": {"tf": 1.7320508075688772}, "cpdbench.control.TestbenchController.TestrunType.VALIDATION_RUN": {"tf": 1.7320508075688772}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 8.426149773176359}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 4}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1.7320508075688772}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 4.898979485566356}, "cpdbench.control.TestrunController": {"tf": 1.7320508075688772}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1.7320508075688772}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 4.69041575982343}, "cpdbench.control.ValidationRunController": {"tf": 1.7320508075688772}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1.7320508075688772}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 4.69041575982343}, "cpdbench.dataset": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset": {"tf": 1.7320508075688772}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1.7320508075688772}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 4.795831523312719}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.file_path": {"tf": 1.7320508075688772}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.dtype": {"tf": 1.7320508075688772}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1.7320508075688772}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 3.4641016151377544}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 3.4641016151377544}, "cpdbench.dataset.CPD2DNdarrayDataset": {"tf": 1.7320508075688772}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset": {"tf": 1.7320508075688772}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.__init__": {"tf": 1.7320508075688772}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 3.4641016151377544}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1.7320508075688772}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 3.4641016151377544}, "cpdbench.dataset.CPDDataset": {"tf": 1.7320508075688772}, "cpdbench.dataset.CPDDataset.CPDDataset": {"tf": 1.7320508075688772}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1.7320508075688772}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 3.4641016151377544}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 3.4641016151377544}, "cpdbench.examples": {"tf": 1.7320508075688772}, "cpdbench.examples.ExampleAlgorithms": {"tf": 1.7320508075688772}, "cpdbench.examples.ExampleAlgorithms.numpy_array_accesses": {"tf": 1.7320508075688772}, "cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1.7320508075688772}, "cpdbench.examples.ExampleDatasets": {"tf": 1.7320508075688772}, "cpdbench.examples.ExampleDatasets.get_extreme_large_dataset_from_file": {"tf": 1.7320508075688772}, "cpdbench.examples.ExampleDatasets.dataset_get_apple_dataset": {"tf": 1.7320508075688772}, "cpdbench.examples.ExampleDatasets.dataset_get_bitcoin_dataset": {"tf": 1.7320508075688772}, "cpdbench.examples.ExampleMetrics": {"tf": 1.7320508075688772}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_Parameters": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_Parameters.cpdb": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_Parameters.get_apple_dataset": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_Parameters.get_bitcoin_dataset": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_Parameters.execute_esst_test": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_Parameters.calc_accuracy": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_Simple": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_Simple.cpdb": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_Simple.get_apple_dataset": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_Simple.get_bitcoin_dataset": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_Simple.execute_esst_test": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_Simple.calc_accuracy": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_VeryLargeDataset": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_VeryLargeDataset.cpdb": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_VeryLargeDataset.get_large_dataset": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_VeryLargeDataset.execute_algorithm": {"tf": 1.7320508075688772}, "cpdbench.examples.Example_VeryLargeDataset.compute_metric": {"tf": 1.7320508075688772}, "cpdbench.exception": {"tf": 1.7320508075688772}, "cpdbench.exception.AlgorithmExecutionException": {"tf": 1.7320508075688772}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1.4142135623730951}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.__init__": {"tf": 1.7320508075688772}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException.standard_msg": {"tf": 1.7320508075688772}, "cpdbench.exception.CPDExecutionException": {"tf": 1.7320508075688772}, "cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1.7320508075688772}, "cpdbench.exception.CPDExecutionException.CPDExecutionException.__init__": {"tf": 1.7320508075688772}, "cpdbench.exception.ConfigurationException": {"tf": 1.7320508075688772}, "cpdbench.exception.ConfigurationException.ConfigurationException": {"tf": 1.7320508075688772}, "cpdbench.exception.ConfigurationException.ConfigurationException.__init__": {"tf": 1.7320508075688772}, "cpdbench.exception.ConfigurationException.ConfigurationException.exc_message": {"tf": 1.7320508075688772}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"tf": 1.4142135623730951}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.__init__": {"tf": 1.7320508075688772}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException.exc_message": {"tf": 1.7320508075688772}, "cpdbench.exception.DatasetFetchException": {"tf": 1.7320508075688772}, "cpdbench.exception.DatasetFetchException.DatasetFetchException": {"tf": 1.4142135623730951}, "cpdbench.exception.DatasetFetchException.DatasetFetchException.__init__": {"tf": 1.7320508075688772}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1.4142135623730951}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.__init__": {"tf": 1.7320508075688772}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException.standard_msg_create_dataset": {"tf": 1.7320508075688772}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"tf": 1.4142135623730951}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.__init__": {"tf": 1.7320508075688772}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException.standard_msg_load_feature": {"tf": 1.7320508075688772}, "cpdbench.exception.DatasetFetchException.SignalLoadingException": {"tf": 1.4142135623730951}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.__init__": {"tf": 1.7320508075688772}, "cpdbench.exception.DatasetFetchException.SignalLoadingException.standard_msg_load_signal": {"tf": 1.7320508075688772}, "cpdbench.exception.MetricExecutionException": {"tf": 1.7320508075688772}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1.4142135623730951}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.__init__": {"tf": 1.7320508075688772}, "cpdbench.exception.MetricExecutionException.MetricExecutionException.standard_msg": {"tf": 1.7320508075688772}, "cpdbench.exception.ResultSetInconsistentException": {"tf": 1.7320508075688772}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1.7320508075688772}, "cpdbench.exception.UserParameterDoesNotExistException": {"tf": 1.7320508075688772}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1.7320508075688772}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.__init__": {"tf": 1.7320508075688772}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException.msg_text": {"tf": 1.7320508075688772}, "cpdbench.exception.ValidationException": {"tf": 1.7320508075688772}, "cpdbench.exception.ValidationException.ValidationException": {"tf": 1.7320508075688772}, "cpdbench.exception.ValidationException.InputValidationException": {"tf": 1.7320508075688772}, "cpdbench.exception.ValidationException.AlgorithmValidationException": {"tf": 1.7320508075688772}, "cpdbench.exception.ValidationException.MetricValidationException": {"tf": 1.7320508075688772}, "cpdbench.exception.ValidationException.DatasetValidationException": {"tf": 1.7320508075688772}, "cpdbench.task": {"tf": 1.7320508075688772}, "cpdbench.task.AlgorithmExecutionTask": {"tf": 1.7320508075688772}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1.7320508075688772}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 4.69041575982343}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1.7320508075688772}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1.7320508075688772}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1.7320508075688772}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 3.3166247903554}, "cpdbench.task.DatasetFetchTask": {"tf": 1.7320508075688772}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1.7320508075688772}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 4.69041575982343}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1.7320508075688772}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1.7320508075688772}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1.7320508075688772}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 3.3166247903554}, "cpdbench.task.MetricExecutionTask": {"tf": 1.7320508075688772}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1.7320508075688772}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 4.69041575982343}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1.7320508075688772}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1.7320508075688772}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1.7320508075688772}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 3.3166247903554}, "cpdbench.task.Task": {"tf": 1.7320508075688772}, "cpdbench.task.Task.TaskType": {"tf": 1.4142135623730951}, "cpdbench.task.Task.TaskType.DATASET_FETCH": {"tf": 1.7320508075688772}, "cpdbench.task.Task.TaskType.ALGORITHM_EXECUTION": {"tf": 1.7320508075688772}, "cpdbench.task.Task.TaskType.METRIC_EXECUTION": {"tf": 1.7320508075688772}, "cpdbench.task.Task.Task": {"tf": 1.7320508075688772}, "cpdbench.task.Task.Task.__init__": {"tf": 4.69041575982343}, "cpdbench.task.Task.Task.execute": {"tf": 1.7320508075688772}, "cpdbench.task.Task.Task.validate_task": {"tf": 1.7320508075688772}, "cpdbench.task.Task.Task.validate_input": {"tf": 1.7320508075688772}, "cpdbench.task.Task.Task.get_task_name": {"tf": 3.3166247903554}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 3.3166247903554}, "cpdbench.task.TaskFactory": {"tf": 1.7320508075688772}, "cpdbench.task.TaskFactory.TaskFactory": {"tf": 1.4142135623730951}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 5}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 5}, "cpdbench.utils": {"tf": 1.7320508075688772}, "cpdbench.utils.BenchConfig": {"tf": 2.449489742783178}, "cpdbench.utils.BenchConfig.logging_file_name": {"tf": 1.7320508075688772}, "cpdbench.utils.BenchConfig.logging_level": {"tf": 1.7320508075688772}, "cpdbench.utils.BenchConfig.logging_console_level": {"tf": 1.7320508075688772}, "cpdbench.utils.BenchConfig.multiprocessing_enabled": {"tf": 1.7320508075688772}, "cpdbench.utils.BenchConfig.result_file_name": {"tf": 1.7320508075688772}, "cpdbench.utils.BenchConfig.get_user_config": {"tf": 1.4142135623730951}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1.4142135623730951}, "cpdbench.utils.BenchConfig.load_config": {"tf": 4.69041575982343}, "cpdbench.utils.Logger": {"tf": 1.7320508075688772}, "cpdbench.utils.Logger.init_logger": {"tf": 1.7320508075688772}, "cpdbench.utils.Logger.get_application_logger": {"tf": 1.7320508075688772}, "cpdbench.utils.UserConfig": {"tf": 1.7320508075688772}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 3.3166247903554}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 3.4641016151377544}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 4.47213595499958}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 5.0990195135927845}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 4.69041575982343}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 3.3166247903554}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1.7320508075688772}, "cpdbench.utils.Utils": {"tf": 1.7320508075688772}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 4.47213595499958}}, "df": 209, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.CPDBench.CPDBench": {"tf": 1}, "cpdbench.control": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}}, "df": 4}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"cpdbench.CPDBench.CPDBench.metric": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 2.449489742783178}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.execute": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.exception.ValidationException.MetricValidationException": {"tf": 1}}, "df": 13, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1.4142135623730951}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}}, "df": 5}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}}, "df": 3}}}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 7, "s": {"docs": {"cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}}, "df": 3}}}}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}}, "df": 1}}}}}}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.4142135623730951}}, "df": 7}}}}}}}, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}}, "df": 1}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.exception.ValidationException.InputValidationException": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.CPDBench.CPDBench": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.dataset": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset": {"tf": 1}, "cpdbench.task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}}, "df": 19, "e": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control": {"tf": 1}, "cpdbench.dataset": {"tf": 1}, "cpdbench.exception": {"tf": 1}, "cpdbench.utils": {"tf": 1.4142135623730951}}, "df": 4}}}}}}, "p": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.dataset": {"tf": 1}}, "df": 1, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.CPDBench.CPDBench": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}, "cpdbench.task.Task.TaskType": {"tf": 1}}, "df": 3}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.CPDBench.CPDBench.dataset": {"tf": 1}, "cpdbench.dataset": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException": {"tf": 1}}, "df": 6}}}}}}}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}}, "df": 2}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1.4142135623730951}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1}}, "df": 2}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1.4142135623730951}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1.4142135623730951}, "cpdbench.exception.ConfigurationException.ConfigurationException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1.7320508075688772}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1.4142135623730951}, "cpdbench.utils.BenchConfig.load_config": {"tf": 2.23606797749979}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1.7320508075688772}}, "df": 12, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.utils": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1}}, "df": 7, "s": {"docs": {"cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType": {"tf": 1}}, "df": 2}}}}}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.utils.BenchConfig": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.dataset": {"tf": 1}, "cpdbench.exception": {"tf": 1}, "cpdbench.task": {"tf": 1}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 8}, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult": {"tf": 1}}, "df": 7, "s": {"docs": {"cpdbench.control.CPDResult.CPDResult": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.utils": {"tf": 1}}, "df": 7}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestbenchController.TestbenchController": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}}, "df": 4}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}}, "df": 2, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}}, "df": 1}, "o": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": null}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": null}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": null}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": null}, "cpdbench.task.Task.Task.__init__": {"tf": null}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": null}}, "df": 6}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}}, "df": 2}}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 1}}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1}}, "df": 3}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1}}, "df": 9, "l": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.control.TestrunController.TestrunController": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}}, "df": 2}}}}}}}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}}, "df": 4}}}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}}, "df": 2}}, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}}, "df": 4}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}}, "df": 2}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.CPDBench.CPDBench.dataset": {"tf": 1}, "cpdbench.task": {"tf": 1}}, "df": 2, "d": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}}, "df": 3}, "s": {"docs": {"cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.task.TaskFactory.TaskFactory": {"tf": 1}}, "df": 1}}}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.CPDBench.CPDBench.algorithm": {"tf": 1}, "cpdbench.CPDBench.CPDBench.metric": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}}, "df": 5, "s": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}}, "df": 1}}}}}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}}, "df": 4}}}, "s": {"docs": {"cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task.execute": {"tf": 1.4142135623730951}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1.7320508075688772}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}}, "df": 17, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 1, "d": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1.7320508075688772}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1.4142135623730951}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}}, "df": 3}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}}, "df": 1}}}}}}}}, "l": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1, "s": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}}, "df": 2}, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.utils.BenchConfig": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.utils.UserConfig.UserConfig": {"tf": 1.4142135623730951}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"cpdbench.exception": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.CPDBench.CPDBench": {"tf": 1}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.CPDBench.CPDBench.dataset": {"tf": 1}, "cpdbench.CPDBench.CPDBench.algorithm": {"tf": 1}, "cpdbench.CPDBench.CPDBench.metric": {"tf": 1}, "cpdbench.control": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult": {"tf": 1.4142135623730951}, "cpdbench.control.CPDValidationResult.CPDValidationResult": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1.7320508075688772}, "cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1.7320508075688772}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.Task.TaskType": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task.get_task_name": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1.7320508075688772}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.7320508075688772}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 46, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1.7320508075688772}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1.7320508075688772}, "cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 2}}, "df": 12, "s": {"docs": {"cpdbench.CPDBench.CPDBench": {"tf": 1}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.CPDBench.CPDBench.dataset": {"tf": 1}, "cpdbench.CPDBench.CPDBench.algorithm": {"tf": 1}, "cpdbench.CPDBench.CPDBench.metric": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1.7320508075688772}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1.4142135623730951}}, "df": 10}}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.CPDBench.CPDBench.validate": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}}, "df": 1}}}}}}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1.4142135623730951}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1.4142135623730951}, "cpdbench.utils.BenchConfig.load_config": {"tf": 2.23606797749979}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}}, "df": 14}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.utils.BenchConfig": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.exception.ValidationException.AlgorithmValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.MetricValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.DatasetValidationException": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}}, "df": 12}, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}}, "df": 5}}}}, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1.4142135623730951}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 3}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}}, "df": 3}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.task": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory": {"tf": 1}}, "df": 2}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.exception": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1}, "cpdbench.utils": {"tf": 1}}, "df": 8}}}}}}}, "o": {"docs": {}, "df": 0, "m": {"docs": {"cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"tf": 1}}, "df": 7}}}}}, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}}, "df": 1}}}}}}}}, "a": {"docs": {"cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1.7320508075688772}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1.4142135623730951}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1.4142135623730951}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"tf": 1.4142135623730951}, "cpdbench.exception.DatasetFetchException.SignalLoadingException": {"tf": 1.4142135623730951}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1.4142135623730951}, "cpdbench.exception.ValidationException.MetricValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.DatasetValidationException": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 2}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 2}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 2}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 2}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.Task.Task.get_task_name": {"tf": 1}, "cpdbench.utils": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.7320508075688772}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1.4142135623730951}}, "df": 57, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.CPDBench.CPDBench": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}}, "df": 2}}}}}, "n": {"docs": {"cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1.4142135623730951}, "cpdbench.exception.ValidationException.AlgorithmValidationException": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 29, "d": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.execute": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1.4142135623730951}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.dataset": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1}, "cpdbench.task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task.execute": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 29}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1}}}}}, "y": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1.4142135623730951}}, "df": 5}}, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {"cpdbench.CPDBench.CPDBench.algorithm": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 2}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1.4142135623730951}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.execute": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1.4142135623730951}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.exception.ValidationException.AlgorithmValidationException": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 18, "s": {"docs": {"cpdbench.CPDBench.CPDBench.algorithm": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1.4142135623730951}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}}, "df": 7}, "/": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "l": {"docs": {"cpdbench.control": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1.7320508075688772}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1.7320508075688772}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1.4142135623730951}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.dataset": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.exception": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}}, "df": 28}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.utils.BenchConfig.get_user_config": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}}, "df": 1}}}}}}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}}, "df": 1, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}}, "df": 5}, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}}, "df": 2}}}}, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1.4142135623730951}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1.7320508075688772}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1.7320508075688772}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.Task.Task.get_task_name": {"tf": 1}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 33}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}}, "df": 4}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}}, "df": 6}}}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}}, "df": 5}}}}}}}, "e": {"docs": {"cpdbench.control.TestrunController.TestrunController": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.utils": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1.4142135623730951}}, "df": 5}, "g": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}}, "df": 8}}}}}}}}, "b": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDResult.CPDResult": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.dataset": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset": {"tf": 1}, "cpdbench.task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory": {"tf": 1}}, "df": 11}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.exception.ValidationException.InputValidationException": {"tf": 1}}, "df": 1}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1}}, "df": 2}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}}, "df": 2}}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.CPDBench.CPDBench": {"tf": 1}, "cpdbench.CPDBench.CPDBench.start": {"tf": 1.7320508075688772}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1.7320508075688772}, "cpdbench.control": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 2.449489742783178}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 2}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 2}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 2.8284271247461903}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1.7320508075688772}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1.4142135623730951}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1.4142135623730951}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1.4142135623730951}, "cpdbench.control.DatasetExecutor.DatasetExecutor.execute": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1.7320508075688772}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1.7320508075688772}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1.4142135623730951}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1.4142135623730951}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1.4142135623730951}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1.4142135623730951}, "cpdbench.dataset": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1.7320508075688772}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 2}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1.4142135623730951}, "cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 2.449489742783178}, "cpdbench.exception": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1.4142135623730951}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.exception.ValidationException.InputValidationException": {"tf": 1}, "cpdbench.task": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 2}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 2}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 2}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.Task.TaskType": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 2}, "cpdbench.task.Task.Task.execute": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task.validate_input": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task.get_task_name": {"tf": 1}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 1.4142135623730951}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 2}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 2.8284271247461903}, "cpdbench.utils": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 2}, "cpdbench.utils.BenchConfig.get_user_config": {"tf": 1.7320508075688772}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1.7320508075688772}, "cpdbench.utils.BenchConfig.load_config": {"tf": 3}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 2}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1.7320508075688772}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 2.449489742783178}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 2.8284271247461903}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 2}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 2.23606797749979}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 2.449489742783178}}, "df": 95, "n": {"docs": {"cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}}, "df": 1}, "s": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 2}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 11}, "n": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1.7320508075688772}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1.4142135623730951}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1.4142135623730951}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.dataset": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.exception": {"tf": 1}, "cpdbench.task": {"tf": 1}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1.4142135623730951}, "cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 2}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 20}}, "a": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 2}}}, "o": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1.4142135623730951}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1.4142135623730951}, "cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1.7320508075688772}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}, "cpdbench.task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1.4142135623730951}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1.4142135623730951}, "cpdbench.utils.BenchConfig": {"tf": 1.7320508075688772}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 33}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}}, "df": 1, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.control": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 3}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1.4142135623730951}}, "df": 1, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1.4142135623730951}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.exception.ValidationException.ValidationException": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1.4142135623730951}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1.7320508075688772}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1.7320508075688772}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.4142135623730951}}, "df": 21, "s": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.task.Task.TaskType": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 6}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1.7320508075688772}}, "df": 2}}}}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1.4142135623730951}, "cpdbench.task": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 2}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 2}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 2}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1.4142135623730951}, "cpdbench.task.Task.TaskType": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task.__init__": {"tf": 2}, "cpdbench.task.Task.Task.execute": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.get_task_name": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 2.23606797749979}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 2.449489742783178}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1.7320508075688772}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.4142135623730951}}, "df": 35, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor.execute": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}}, "df": 11}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}}, "df": 4}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1.4142135623730951}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 3}, "t": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 2, "s": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 1}}, "w": {"docs": {}, "df": 0, "o": {"docs": {"cpdbench.dataset": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}}, "df": 6, "s": {"docs": {"cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}}, "df": 6}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.TestrunController.TestrunController": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}}, "df": 4}}}}}}}}, "r": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.Task.Task.get_task_name": {"tf": 1}}, "df": 5, "s": {"docs": {"cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1.7320508075688772}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1.7320508075688772}}, "df": 2}}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}}, "df": 1, "s": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.TestrunController.TestrunController": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.utils.BenchConfig": {"tf": 1}}, "df": 1}}}}}}}, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException": {"tf": 1}}, "df": 4}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}}, "df": 3}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 2}}}}}}}}}}, "l": {"docs": {}, "df": 0, "f": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1.4142135623730951}}, "df": 1}}, "t": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}}, "df": 2}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1.7320508075688772}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 3}}}}}, "u": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}}, "df": 1}}}}}}}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 3}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 1, "s": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1}}}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 1}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 1}}}}}}}}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}}, "df": 2}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.exception.ValidationException.ValidationException": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}}, "df": 9, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException": {"tf": 1}, "cpdbench.exception.ValidationException.InputValidationException": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 4}}}}}}}}, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}}, "df": 2}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 6}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}}, "df": 3}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}}, "df": 1}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"cpdbench.exception.ValidationException.InputValidationException": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 2}}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 11, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}}, "df": 2}}}}}}}}}}, "s": {"docs": {"cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1.4142135623730951}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"cpdbench.CPDBench.CPDBench.algorithm": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}}, "df": 3, "s": {"docs": {"cpdbench.control.DatasetExecutor.DatasetExecutor.execute": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}}, "df": 8}, "d": {"docs": {"cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 13}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 2.23606797749979}, "cpdbench.exception": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.exception.ValidationException.ValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.InputValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.AlgorithmValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.MetricValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.DatasetValidationException": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}}, "df": 26}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}}, "df": 2, "s": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1}}, "df": 3}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 9}}}}, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1}}, "df": 1}}}}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}, "cpdbench.task.Task.TaskType": {"tf": 1}}, "df": 2}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.DatasetExecutor.DatasetExecutor.execute": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.CPDBench.CPDBench.metric": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.utils": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.control": {"tf": 1}, "cpdbench.utils": {"tf": 1}}, "df": 2}}}}}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1.7320508075688772}, "cpdbench.exception.ConfigurationException.ConfigurationException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"tf": 1}}, "df": 4, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1.4142135623730951}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1.4142135623730951}, "cpdbench.exception.ConfigurationException.ConfigurationException": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1.7320508075688772}}, "df": 4}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}}, "df": 3}}}, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "c": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1}}, "df": 3}}}, "o": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 2}}, "df": 2, "f": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 2}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 2}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1.7320508075688772}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1.7320508075688772}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 2}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.TestrunType": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1.7320508075688772}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 2}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"tf": 1.4142135623730951}, "cpdbench.exception.DatasetFetchException.SignalLoadingException": {"tf": 1.4142135623730951}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}, "cpdbench.exception.ValidationException.AlgorithmValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.MetricValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.DatasetValidationException": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.Task.TaskType": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1.7320508075688772}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 2}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.7320508075688772}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1.4142135623730951}}, "df": 44}, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.utils.BenchConfig.get_user_config": {"tf": 1.4142135623730951}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}}, "df": 18, "s": {"docs": {"cpdbench.CPDBench.CPDBench.dataset": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1.4142135623730951}, "cpdbench.task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1.4142135623730951}}, "df": 9}}}}}}, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}}, "df": 3}}}}}}}, "n": {"docs": {"cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}}, "df": 6, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1.4142135623730951}}, "df": 6}, "c": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 2}}, "l": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 2}}}, "r": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 6, "g": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1}}, "df": 2, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 3}}}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1.4142135623730951}}, "df": 3}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}}, "df": 4}}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}}, "df": 8, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 2.449489742783178}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 2}}, "df": 8, "s": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1.4142135623730951}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.exception.ValidationException.InputValidationException": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 1.4142135623730951}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1.7320508075688772}, "cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 36, "/": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "s": {"docs": {"cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}}, "df": 2}}}, "t": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 4}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1.4142135623730951}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}}, "df": 5}}, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control": {"tf": 1}, "cpdbench.dataset": {"tf": 1}, "cpdbench.exception": {"tf": 1}, "cpdbench.task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1}, "cpdbench.utils": {"tf": 1}}, "df": 9}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 1}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestrunController.TestrunController": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {"cpdbench.control": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}}, "df": 4}}}}}, "e": {"docs": {"cpdbench.task.Task.TaskType": {"tf": 1}}, "df": 1, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.TestbenchController.TestrunType": {"tf": 1}}, "df": 1}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1}}, "df": 3, "s": {"docs": {"cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}}, "df": 1}}}}}}}, "y": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1.4142135623730951}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1}}, "df": 8}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}}, "df": 2}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}}, "df": 1}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 1}}}}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 2}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}}, "df": 3, "s": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.task.Task.TaskType": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.4142135623730951}}, "df": 5}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.CPDBench.CPDBench.dataset": {"tf": 1}, "cpdbench.CPDBench.CPDBench.algorithm": {"tf": 1}, "cpdbench.CPDBench.CPDBench.metric": {"tf": 1}}, "df": 3}}}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.TestrunController.TestrunController": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1}, "cpdbench.task.Task.Task.get_task_name": {"tf": 1}}, "df": 4}}}}}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}}, "df": 4}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}}, "df": 2}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}}, "df": 3, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.CPDBench.CPDBench.dataset": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 2.23606797749979}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1.4142135623730951}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1.7320508075688772}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.exception.ValidationException.DatasetValidationException": {"tf": 1}}, "df": 23, "s": {"docs": {"cpdbench.control.CPDFullResult.CPDFullResult": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.dataset": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}}, "df": 8}}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1.4142135623730951}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1.4142135623730951}}, "df": 14, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 1}}, "df": 9}}}}}}}}, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 4}}}}}}}}, "o": {"docs": {"cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}}, "df": 4}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}}, "df": 1}}}}, "b": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1}}, "df": 3}}, "y": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.CPDBench.CPDBench.start": {"tf": 1}, "cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}}, "df": 4}}, "o": {"docs": {}, "df": 0, "u": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 1}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.CPDBench.CPDBench.validate": {"tf": 1}}, "df": 1, "d": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1}}, "df": 4}, "s": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 9}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1.4142135623730951}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.exception.ValidationException.ValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.InputValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.AlgorithmValidationException": {"tf": 1.4142135623730951}, "cpdbench.exception.ValidationException.MetricValidationException": {"tf": 1.4142135623730951}, "cpdbench.exception.ValidationException.DatasetValidationException": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 21}}}}}}}, "u": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}}, "df": 1, "s": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.4142135623730951}}, "df": 3}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"cpdbench.utils.UserConfig.UserConfig": {"tf": 2.23606797749979}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}}, "df": 2}}}}}}}}, "i": {"docs": {}, "df": 0, "a": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}}, "df": 1}}}}, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}}, "df": 1, "n": {"docs": {"cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 15}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}}, "df": 3}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1.4142135623730951}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 2}}}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException": {"tf": 1}, "cpdbench.exception.ValidationException.ValidationException": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}}, "df": 7}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1.4142135623730951}}, "df": 4}}}}}}, "b": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1.4142135623730951}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1.4142135623730951}, "cpdbench.utils.BenchConfig": {"tf": 1.7320508075688772}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}}, "df": 20, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 7, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.utils.BenchConfig.get_user_config": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}}, "df": 2}}}}}}}}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}}, "df": 1}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}}, "df": 4}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}}, "df": 2}}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}}, "df": 3}}, "e": {"docs": {"cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1.4142135623730951}, "cpdbench.dataset": {"tf": 1}}, "df": 3, "d": {"docs": {"cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {"cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1.4142135623730951}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1.4142135623730951}, "cpdbench.exception": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 14}, "u": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController": {"tf": 1.7320508075688772}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.TestrunType": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}}, "df": 13, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.control": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}}, "df": 5}}}}, "s": {"docs": {"cpdbench.control": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}}, "df": 7}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 2}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.exception.ValidationException.AlgorithmValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.MetricValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.DatasetValidationException": {"tf": 1}}, "df": 9, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1.4142135623730951}}, "df": 1}}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.add_dataset_result": {"tf": 1.7320508075688772}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.control.CPDResult.CPDResult": {"tf": 1}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}}, "df": 25, "s": {"docs": {"cpdbench.CPDBench.CPDBench.metric": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}}, "df": 6}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control": {"tf": 1}}, "df": 1}}}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1.4142135623730951}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.utils.BenchConfig.get_user_config": {"tf": 1}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1}}, "df": 8, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1.4142135623730951}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1.4142135623730951}, "cpdbench.control.CPDResult.CPDResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task.get_task_name": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task.get_param_dict": {"tf": 1.4142135623730951}, "cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.BenchConfig.get_user_config": {"tf": 1}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.7320508075688772}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1.4142135623730951}}, "df": 34}, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1}}}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}}, "df": 1}}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.dataset": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset": {"tf": 1}}, "df": 3}}}, "s": {"docs": {"cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 1}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.utils.BenchConfig": {"tf": 1}}, "df": 1}}, "f": {"docs": {"cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 1, "/": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "f": {"docs": {"cpdbench.CPDBench.CPDBench.validate": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1.4142135623730951}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}, "cpdbench.utils.BenchConfig.get_user_config": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.7320508075688772}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1.4142135623730951}}, "df": 21}, "n": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1.7320508075688772}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 21, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult": {"tf": 1}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_parameters": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_runtimes": {"tf": 1}}, "df": 2}, "s": {"docs": {"cpdbench.dataset": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.exception.ConfigurationException.ConfigurationException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 2}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.exception.ValidationException.InputValidationException": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}}, "df": 8}}}, "t": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1, "o": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.init": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.init": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.init": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1}}, "df": 5}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.utils.BenchConfig.get_user_config": {"tf": 1}}, "df": 1}, "s": {"docs": {"cpdbench.utils.BenchConfig.load_config": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}}, "df": 2, "/": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}, "cpdbench.exception.ValidationException.InputValidationException": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 2}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1.4142135623730951}}, "df": 19}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}}, "df": 1}}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1.4142135623730951}}, "df": 2, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1.4142135623730951}}, "df": 6, "s": {"docs": {"cpdbench.dataset": {"tf": 1}, "cpdbench.task": {"tf": 1}}, "df": 2}}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}}, "df": 4}}}}}}}}}}, "t": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_task": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_task": {"tf": 1}, "cpdbench.task.Task.Task.validate_task": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}}, "df": 7, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 1}}}}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "s": {"docs": {"cpdbench.task": {"tf": 1}}, "df": 1}}, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 1}}}}}}}, "w": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.CPDBench.CPDBench.dataset": {"tf": 1}, "cpdbench.CPDBench.CPDBench.algorithm": {"tf": 1}, "cpdbench.CPDBench.CPDBench.metric": {"tf": 1}, "cpdbench.control.CPDDatasetResult.ErrorType": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1.7320508075688772}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1.4142135623730951}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.utils": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1.7320508075688772}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}}, "df": 24}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.exception.DatasetFetchException.DatasetFetchException": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}}, "df": 2}}, "n": {"docs": {"cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.exception.ValidationException.ValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.InputValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.AlgorithmValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.MetricValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.DatasetValidationException": {"tf": 1}}, "df": 14}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1.7320508075688772}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.get_result_as_dict": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.validate_input": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.validate_input": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.Task.Task.validate_input": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1.4142135623730951}}, "df": 27}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}}, "df": 2}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1.4142135623730951}}, "df": 1}}, "n": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.exception.ValidationException.ValidationException": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_dataset_runtime": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.utils.BenchConfig.get_user_config": {"tf": 1}}, "df": 3}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.exception.CPDExecutionException.CPDExecutionException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.DatasetFetchException": {"tf": 1}, "cpdbench.exception.ValidationException.ValidationException": {"tf": 1}, "cpdbench.exception.ValidationException.InputValidationException": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 5}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1}}, "df": 4}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"cpdbench.control": {"tf": 1}, "cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController": {"tf": 1}}, "df": 3}}, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.utils": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.exception.DatasetFetchException.DatasetFetchException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException": {"tf": 1}}, "df": 3}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1.7320508075688772}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.get_errors_as_list": {"tf": 1.4142135623730951}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1.7320508075688772}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 2}, "cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}, "cpdbench.control.TestbenchController.TestbenchController.execute_testrun": {"tf": 1.7320508075688772}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.4142135623730951}}, "df": 11}}, "k": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 1}}, "b": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 1}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"cpdbench.examples.ExampleMetrics.metric_accuracy_in_allowed_windows": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1.4142135623730951}}, "df": 1}}}, "z": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}}, "df": 3, "d": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.__init__": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1}, "cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}, "cpdbench.exception": {"tf": 1}, "cpdbench.utils": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1}}, "df": 9}, "r": {"docs": {"cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.BenchConfig.get_complete_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_param_dict": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 12, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.utils.BenchConfig.get_user_config": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.__init__": {"tf": 1}}, "df": 2}}}}}}}, "s": {"docs": {"cpdbench.examples.ExampleAlgorithms.algorithm_execute_single_esst": {"tf": 1}}, "df": 1}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}}, "df": 4}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.utils.UserConfig.UserConfig": {"tf": 1}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1}}, "df": 2}}}}, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.task.TaskFactory.TaskFactory.create_task_from_function": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.utils": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_algorithm_result": {"tf": 1}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_metric_score": {"tf": 1.4142135623730951}, "cpdbench.control.CPDDatasetResult.CPDDatasetResult.add_error": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.get_task_name": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.get_task_name": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.get_task_name": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1.4142135623730951}, "cpdbench.task.Task.Task.get_task_name": {"tf": 1.4142135623730951}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.7320508075688772}, "cpdbench.utils.UserConfig.UserConfig.check_if_global_param": {"tf": 1.4142135623730951}, "cpdbench.utils.Utils.get_name_of_function": {"tf": 1.4142135623730951}}, "df": 18, "s": {"docs": {"cpdbench.control.CPDFullResult.CPDFullResult.__init__": {"tf": 1}, "cpdbench.control.CPDValidationResult.CPDValidationResult.__init__": {"tf": 1}}, "df": 2}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.execute": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.execute": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.execute": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}, "cpdbench.task.Task.Task.execute": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1.7320508075688772}}, "df": 10}}}, "p": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.__init__": {"tf": 1.4142135623730951}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}}, "df": 5}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}}, "df": 2}}, "t": {"docs": {"cpdbench.control.ValidationRunController.ValidationRunController": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.exception.ConfigurationException.ConfigurationFileNotFoundException": {"tf": 1}, "cpdbench.exception.ResultSetInconsistentException.ResultSetInconsistentException": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.utils.BenchConfig.load_config": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_user_param": {"tf": 1.4142135623730951}}, "df": 7, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"cpdbench.utils.UserConfig.UserConfig.validate_user_config": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset": {"tf": 1}, "cpdbench.exception.UserParameterDoesNotExistException.UserParameterDoesNotExistException": {"tf": 1}, "cpdbench.task.Task.TaskType": {"tf": 1}, "cpdbench.task.TaskFactory.TaskFactory.create_tasks_with_parameters": {"tf": 1}, "cpdbench.utils.UserConfig.UserConfig.get_number_of_executions": {"tf": 1}}, "df": 5}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}}, "df": 6}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.DatasetExecutor.DatasetExecutor": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {"cpdbench.control.ExecutionController.ExecutionController": {"tf": 1}, "cpdbench.exception.AlgorithmExecutionException.AlgorithmExecutionException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.CPDDatasetCreationException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.FeatureLoadingException": {"tf": 1}, "cpdbench.exception.DatasetFetchException.SignalLoadingException": {"tf": 1}, "cpdbench.exception.MetricExecutionException.MetricExecutionException": {"tf": 1}, "cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1}, "cpdbench.utils.BenchConfig": {"tf": 1}}, "df": 11}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"cpdbench.control.ExecutionController.ExecutionController.execute_run": {"tf": 1}, "cpdbench.control.TestrunController.TestrunController.execute_run": {"tf": 1}, "cpdbench.control.ValidationRunController.ValidationRunController.execute_run": {"tf": 1}}, "df": 3}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask.__init__": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask.__init__": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask.__init__": {"tf": 1}, "cpdbench.task.Task.Task.__init__": {"tf": 1}}, "df": 4}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {"cpdbench.task.AlgorithmExecutionTask.AlgorithmExecutionTask": {"tf": 1}, "cpdbench.task.DatasetFetchTask.DatasetFetchTask": {"tf": 1}, "cpdbench.task.MetricExecutionTask.MetricExecutionTask": {"tf": 1}, "cpdbench.task.Task.Task": {"tf": 1}}, "df": 4}}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, ":": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1}}, "df": 1}}}}}}}}}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder": {"tf": 1.4142135623730951}}, "df": 1, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"cpdbench.control.TestbenchController.ExtendedEncoder.default": {"tf": 1}}, "df": 1}}}}}}}}}}}, "x": {"docs": {"cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPD2DFromFileDataset.CPD2DFromFileDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_validation_preview": {"tf": 1}, "cpdbench.dataset.CPD2DNdarrayDataset.CPD2DNdarrayDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_signal": {"tf": 1}, "cpdbench.dataset.CPDDataset.CPDDataset.get_validation_preview": {"tf": 1}}, "df": 6}}}}, "pipeline": ["trimmer"], "_isPrebuiltIndex": true}; + + // mirrored in build-search-index.js (part 1) + // Also split on html tags. this is a cheap heuristic, but good enough. + elasticlunr.tokenizer.setSeperator(/[\s\-.;&_'"=,()]+|<[^>]*>/); + + let searchIndex; + if (docs._isPrebuiltIndex) { + console.info("using precompiled search index"); + searchIndex = elasticlunr.Index.load(docs); + } else { + console.time("building search index"); + // mirrored in build-search-index.js (part 2) + searchIndex = elasticlunr(function () { + this.pipeline.remove(elasticlunr.stemmer); + this.pipeline.remove(elasticlunr.stopWordFilter); + this.addField("qualname"); + this.addField("fullname"); + this.addField("annotation"); + this.addField("default_value"); + this.addField("signature"); + this.addField("bases"); + this.addField("doc"); + this.setRef("fullname"); + }); + for (let doc of docs) { + searchIndex.addDoc(doc); + } + console.timeEnd("building search index"); + } + + return (term) => searchIndex.search(term, { + fields: { + qualname: {boost: 4}, + fullname: {boost: 2}, + annotation: {boost: 2}, + default_value: {boost: 2}, + signature: {boost: 2}, + bases: {boost: 2}, + doc: {boost: 1}, + }, + expand: true + }); +})(); \ No newline at end of filethe name of the function
\n