From 23ffa7d4e0dfe761e591ebd657e349cc3ec2132b Mon Sep 17 00:00:00 2001 From: YileAllenChen1 Date: Tue, 29 Sep 2020 09:52:36 -0500 Subject: [PATCH] fix Matrix Profile Former-commit-id: 0508fe1e5bfdc2c202ab9a190e7d9a4d51bbd4cb [formerly d0b3fb94dd5edac21db7cb4762691241f9a04154] [formerly 7c3f333e68e145a89df19d3d91b48e07d1addca6 [formerly 4305068a1f2798dab0490b641dc812e1e5845f8a]] [formerly 95f4a7b3c97a3fca6d8510f98631935ae6b65cb2 [formerly 031dc9615fa986d21a2535226cc268a37b71add6] [formerly 656d01fdc5bd9abdd08d34b1323700e0a27e9312 [formerly 924889df3cce3eefa319cc5c1e05ddc26e66b6c4]]] [formerly 312fc70109a6c3b802c3ccb7d14ca1c9ab8ba54e [formerly 57e72d9cf874ae1ebd59b387e16aa0c21bdef53c] [formerly abad9b547e7de3cf24549acc4b2c2b99dcaa8149 [formerly 01e6885b91d781782f2176688f4a8609b25247e3]] [formerly 9cfbce8dd01b7ff2d4e3cd426a478d28fa15ce19 [formerly 8b3731e595eb62e99685f71d8aa76ffb342a9c72] [formerly 3b02e0b6c4ddea548e7dd0d681221f0937027ba0 [formerly 66004e8d6b0cce78eb99f1cbb9fc399a4d3496f4]]]] [formerly a05a7725d87fbe2263a84509074f21e155e6c60f [formerly dd8cbdebe7fb705b6880757fa316525000746310] [formerly 2d0d09fd432d4a4e34e7bdb61be810016f36a9a9 [formerly fb3c187cc3c70585176cfd2399608cc019c562f7]] [formerly 41e49270d34204b74babb7baf453c854c6188a3b [formerly d44b99c4d6decf04e01b17a8c0a1e9e028b44798] [formerly 6e7b553b41f9a305074548bd6e72186c5e8662ad [formerly f915a1c9613369412e168717b263c25f5cd98dea]]] [formerly 6355c7704b7d1d83ef496d6bede3c221cc6a5ebd [formerly f5f8be010b4fdecf28e983236260bde5cd55988d] [formerly 6d56c08ca79821b54f436f198ee8fbd402be509d [formerly d8cf71171207b2d95bd66ef3711748ff1a0937ee]] [formerly 79dbdc61f6ae54b89922b452ac485b51e9253da8 [formerly 0eef28d35ab4c20afecb6336aae87b62a935adba] [formerly 5486eef3ccd0c079ab44095eb56085c76f751829 [formerly 7b29a01635c89e0874d38d10aab8c96ec2c563df]]]]] [formerly 8a24c3e8994877a726180ff015ae08a5ddf63575 [formerly 1b589c10177c8ac33b8aa3ab1ff445e5ba1a3bc5] [formerly 040f062e3353ba7ae42626bd3fd2ed600d470def [formerly 84e580cfa0bf717dce71a634e58aa9c41f501e3f]] [formerly cec9f82649fd4f35dac5d8b8ae2941de57dfffcc [formerly e7b85d5c41a855ace3a3a67f650d4787a9e78f47] [formerly 9c4ea83829343e6e9578a6f57b45c576e735ff6a [formerly c02155e6763d6f15538f52fe698177239c82fdfe]]] [formerly b2149dc9bff03092d9abb9d3368b3cbad67a81cc [formerly 09d9c1fd48ebc6a4e174ef35feeb260d634b915d] [formerly 1360f95ce66f095852781b5e3117de150519d687 [formerly 1b35ce4662bd4e509c8e0bcc509970a48f06a4e5]] [formerly 5e2bff709938de397136807a1a8964385e5e0782 [formerly 3ab76ed0a8b0cd67010ec94e86d470c548bbe88a] [formerly ddc6f3f5d9ce4bf5b1b67a01762ad78e9b2e20ca [formerly 41ca6c9dfa6d1fa35ac0209e64d5da07592a4986]]]] [formerly c48844dddb4c311062320c5b894212ace521c3ba [formerly 58f86baada74da357113bd32f19570b7789ae1e4] [formerly 0215dc168593678f6b42468dce9a1c7c6f1a758a [formerly 7b7d5f9b5955bb42e520e156bf8fa1cc3d1f9fc9]] [formerly 8cbacb9ec4726eab05214718533d943f2fb54634 [formerly 7aa727b7c5b321a70f5577d428b6d1558491a4b6] [formerly f3831122d4d01184b0bd41cfc493552ddb80c6ee [formerly 714eab81920cb95654e99550712a519d330dec51]]] [formerly 0cc1d60ac45b12b13365dae71e2ffa0042e7449c [formerly 6fc93900ec573a2b7676f7aaec030f50ad3269ec] [formerly e5297790f96b4168b83516413e6c8d9cae7beb7b [formerly a8642bec67ca9dcb7a66344d22a609b12b99b440]] [formerly db79caaeb2a0bbc2fd02cbd25338d02f149ca1ac [formerly 4cbb2c66ecf2f6fe8fa0e8964d48edf9e4316fe8] [formerly d774596516ca8d8428b610ef7e63e35f2d1a845f [formerly d37f461764ecf0077e74ad63b472907413b8fbb6]]]]]] Former-commit-id: 3015eb1cc4c78d4837599d9c541d8089dc847624 [formerly a64305ecf479c39f8e036a521466b2ea8f098614] [formerly 4530cd0caf15821127dea338e233830eb229b427 [formerly e8d18e69522e27c27e1f84499ed84c8632e4ae22]] [formerly 06fb7cca7603cee982308a51e19dbc7a3d9695f9 [formerly b8a703c4b72565ae800011f5b32607008922a7fa] [formerly cd8c7f568b290fddbd9cd2c877f25a4a4c845f23 [formerly 66017cc4a10ee9a6f4728e9d2dc71713da3c420e]]] [formerly ef6ce5f4935ee5a151471b3256f360f2f0077ef8 [formerly 88cc50cf34c7798aecb942e880a802d78dfc1716] [formerly 73d0297fafe65cc9dbb2e2cacffccf8764e115a8 [formerly c06b8ca6bfc92090ce647c1441db2ee87a18e33c]] [formerly bb8038d0d6598497c121a2fd68a86ed8ba771776 [formerly 80dc4d12508c94622b7dc99e147cba0d8da82774] [formerly e8b478993c9f7e9f63782ab6736f2ad8d18f9a02 [formerly 06d1552277565562f34837657bfc819df6d8498c]]]] [formerly 7f98e080dedda098cf571bedd971ee0ecc3314b5 [formerly f67b72cacd571021312f4385ea5ac30040740593] [formerly f7fbb3b29b494e1ca949d68da17ca80fbe380222 [formerly cd29a7f67e877e892a85b8afb41879ce526e43da]] [formerly 437b99656682dfd9ca4cd03af867492dfe1a649a [formerly 8b2edd8e63dd01f57fda72d8bdc08d2d6636c37c] [formerly 72b1f39938fa9a0edd6e309d397b7f65429e5365 [formerly af56782e86515d1e4975aaad649bc0ec8af75721]]] [formerly f536760edf9cdc7b6f0afad8cd6fb3d642d23a3b [formerly 8f7bac2c41d63f11823108bec7ffaf0c96965329] [formerly 0dfae2f4f4913960d6fa141b03b37c220aefcaf1 [formerly d50b85199758c6570fb0293fbd18c9d1cf8b5797]] [formerly ecbc336970e6d55f978b931cbb310aa4af418b2c [formerly 3f569a667c59939491957909e173cfca6c8279a9] [formerly d774596516ca8d8428b610ef7e63e35f2d1a845f]]]] Former-commit-id: a3ef8e16451a4f4c620d207d57719b6bbe2fd588 [formerly 0c32def7ea06b1d7bf22c8f6088f1e4118f97a45] [formerly 31956558b4304614539d74cf098bbac585bc9185 [formerly 79ddf764ec84781066bce800dde969c9946f24a3]] [formerly 519a814bbabbf2f850ae02c27abdf2558a178b6f [formerly 8d1f02b718d1278479fa099e93e87610aeb7d22d] [formerly dcb257483e4c00539231838825f2d1b789c0ae90 [formerly bf314d29631e3ca779347b56a5e7bad12e80d8e1]]] [formerly c252ff726faf4e225953d66f13953ba2f1d940c9 [formerly dcc58f2b657e703044bc3e111bb83b6916e25422] [formerly 8e11b7d98b3b5ae0bf173293137f4a2b28b42d0f [formerly 4e593a6a4e53d3de503cdfa51ca4eadfa3aa5d50]] [formerly d69fdc8418b61e7b51b5f0c32181e595497a6a7d [formerly 39d03951c598f4883804a1762a68e30c32b6905b] [formerly 897abe34dab0bc56b50821d6319b7e343a68fd1c [formerly effe430c15b2aeca48047431f7b45d8dd77316d2]]]] Former-commit-id: 9ed7c019c412cb5e778aae1bf5ac5befa632a7e4 [formerly d5df678f5877defe14d49e79bf9c1a015c4983b1] [formerly 1fd3454089ba9f7bc3e5b8b5f2a3a42c5be3a72f [formerly d60807a2f21b637add28cb86ec4172a285b3a5c9]] [formerly 050e055a69826681714e30e5684b0b4338c7f865 [formerly d0a3cafca349c71b76900a25518defac00692d70] [formerly ed7354fb857ddd8f5d5afaac5c5717a28c7f111d [formerly f51f3656430bf0df6a5abba7e050f615976c619b]]] Former-commit-id: 6e5f45be96015a3b474246d3502399f0177e2c23 [formerly 9b18b3e2a4433aedafebc034f1d6f013193a35be] [formerly 53339f81ebfc5d4935ba439ce33f1fe1bf1c29ec [formerly bb990bdcb8bda95515b4728f050b26a4e8664fb1]] Former-commit-id: 8627ac9e6a6424feb5e22e7808d3eb87f7178254 [formerly ab62a81a38d2b8ae177c288750680afa152c3dd8] Former-commit-id: 01a577e551bd123efdcccb37d4884882cef776ff --- tods/detection_algorithm/MatrixProfile.py | 377 ++++++++++++++++++++++++------ tods/tests/test_MatrixProfile.py | 2 +- 2 files changed, 305 insertions(+), 74 deletions(-) diff --git a/tods/detection_algorithm/MatrixProfile.py b/tods/detection_algorithm/MatrixProfile.py index da50b67..93d9ef3 100644 --- a/tods/detection_algorithm/MatrixProfile.py +++ b/tods/detection_algorithm/MatrixProfile.py @@ -1,56 +1,99 @@ -from typing import Any, Callable, List, Dict, Union, Optional, Sequence, Tuple -from numpy import ndarray -from collections import OrderedDict -from scipy import sparse import os import sklearn import numpy import typing +import time +from scipy import sparse +from numpy import ndarray +from collections import OrderedDict +from typing import Any, Callable, List, Dict, Union, Optional, Sequence, Tuple -# Custom import commands if any -import warnings import numpy as np -from sklearn.utils import check_array -from sklearn.exceptions import NotFittedError -# from numba import njit -from pyod.utils.utility import argmaxn +import pandas as pd +import logging, uuid +from scipy import sparse +from numpy import ndarray +from collections import OrderedDict +from common_primitives import dataframe_utils, utils -from d3m.container.numpy import ndarray as d3m_ndarray -from d3m.container import DataFrame as d3m_dataframe -from d3m.metadata import hyperparams, params, base as metadata_base from d3m import utils +from d3m import container from d3m.base import utils as base_utils from d3m.exceptions import PrimitiveNotFittedError +from d3m.container import DataFrame as d3m_dataframe +from d3m.container.numpy import ndarray as d3m_ndarray +from d3m.primitive_interfaces import base, transformer +from d3m.metadata import base as metadata_base, hyperparams +from d3m.metadata import hyperparams, params, base as metadata_base from d3m.primitive_interfaces.base import CallResult, DockerContainer -# from d3m.primitive_interfaces.supervised_learning import SupervisedLearnerPrimitiveBase -from d3m.primitive_interfaces.unsupervised_learning import UnsupervisedLearnerPrimitiveBase -from d3m.primitive_interfaces.transformer import TransformerPrimitiveBase - -from d3m.primitive_interfaces.base import ProbabilisticCompositionalityMixin, ContinueFitMixin -from d3m import exceptions -import pandas -import uuid - -from d3m import container, utils as d3m_utils - -from .UODBasePrimitive import Params_ODBase, Hyperparams_ODBase, UnsupervisedOutlierDetectorBase import stumpy -# from typing import Union -Inputs = d3m_dataframe -Outputs = d3m_dataframe +__all__ = ('MatrixProfile',) +Inputs = container.DataFrame +Outputs = container.DataFrame +class PrimitiveCount: + primitive_no = 0 -class Params(Params_ODBase): - ######## Add more Attributes ####### - pass +class Hyperparams(hyperparams.Hyperparams): + window_size = hyperparams.UniformInt( + lower = 0, + upper = 100, #TODO: Define the correct the upper bound + default=50, + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="window size to calculate" + ) + + # Keep previous + dataframe_resource = hyperparams.Hyperparameter[typing.Union[str, None]]( + default=None, + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Resource ID of a DataFrame to extract if there are multiple tabular resources inside a Dataset and none is a dataset entry point.", + ) + use_columns = hyperparams.Set( + elements=hyperparams.Hyperparameter[int](-1), + default=(2,), + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="A set of column indices to force primitive to operate on. If any specified column cannot be parsed, it is skipped.", + ) + exclude_columns = hyperparams.Set( + elements=hyperparams.Hyperparameter[int](-1), + default=(0,1,3,), + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="A set of column indices to not operate on. Applicable only if \"use_columns\" is not provided.", + ) + return_result = hyperparams.Enumeration( + values=['append', 'replace', 'new'], + default='new', + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Should parsed columns be appended, should they replace original columns, or should only parsed columns be returned? This hyperparam is ignored if use_semantic_types is set to false.", + ) + use_semantic_types = hyperparams.UniformBool( + default=False, + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Controls whether semantic_types metadata will be used for filtering columns in input dataframe. Setting this to false makes the code ignore return_result and will produce only the output dataframe" + ) + add_index_columns = hyperparams.UniformBool( + default=False, + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Also include primary index columns if input data has them. Applicable only if \"return_result\" is set to \"new\".", + ) + error_on_no_input = hyperparams.UniformBool( + default=True, + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Throw an exception if no input column is selected/provided. Defaults to true to behave like sklearn. To prevent pipelines from breaking set this to False.", + ) + return_semantic_type = hyperparams.Enumeration[str]( + values=['https://metadata.datadrivendiscovery.org/types/Attribute', + 'https://metadata.datadrivendiscovery.org/types/ConstructedAttribute'], + default='https://metadata.datadrivendiscovery.org/types/Attribute', + description='Decides what semantic type to attach to generated attributes', + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'] + ) -class Hyperparams(Hyperparams_ODBase): - ######## Add more Attributes ####### - pass class MP: """ @@ -80,10 +123,9 @@ class MP: #transformed_columns[col]=output #print(transformed_columns) return transformed_columns - -class MatrixProfile(UnsupervisedOutlierDetectorBase[Inputs, Outputs, Params, Hyperparams]): - """ +class MatrixProfile(transformer.TransformerPrimitiveBase[Inputs, Outputs, Hyperparams]): + """ A primitive that performs matrix profile on a DataFrame using Stumpy package Stumpy documentation: https://stumpy.readthedocs.io/en/latest/index.html @@ -99,7 +141,7 @@ class MatrixProfile(UnsupervisedOutlierDetectorBase[Inputs, Outputs, Params, Hyp ignore_trivial : bool Set to `True` if this is a self-join. Otherwise, for AB-join, set this to `False`. Default is `True`. - Returnsfdsf + Returns ------- out : ndarray The first column consists of the matrix profile, the second column @@ -109,6 +151,7 @@ class MatrixProfile(UnsupervisedOutlierDetectorBase[Inputs, Outputs, Params, Hyp """ + metadata = metadata_base.PrimitiveMetadata({ '__author__': "DATA Lab @Texas A&M University", 'name': "Matrix Profile", @@ -124,66 +167,254 @@ class MatrixProfile(UnsupervisedOutlierDetectorBase[Inputs, Outputs, Params, Hyp }) - def __init__(self, *, - hyperparams: Hyperparams, # - random_seed: int = 0, - docker_containers: Dict[str, DockerContainer] = None) -> None: - super().__init__(hyperparams=hyperparams, random_seed=random_seed, docker_containers=docker_containers) + def __init__(self, *, hyperparams: Hyperparams) -> None: + super().__init__(hyperparams=hyperparams) + self._clf = MP(window_size = hyperparams['window_size']) + self.primitiveNo = PrimitiveCount.primitive_no + PrimitiveCount.primitive_no+=1 - self._clf = MP(window_size=hyperparams['window_size']) + def produce(self, *, inputs: Inputs, timeout: float = None, iterations: int = None) -> base.CallResult[Outputs]: - def set_training_data(self, *, inputs: Inputs) -> None: """ - Set training data for outlier detection. + Args: + inputs: Container DataFrame + timeout: Default + + iterations: Default + Returns: - None + + Container DataFrame containing Matrix Profile of selected columns + """ - super().set_training_data(inputs=inputs) - def fit(self, *, timeout: float = None, iterations: int = None) -> CallResult[None]: + # Get cols to fit. + self._fitted = False + self._training_inputs, self._training_indices = self._get_columns_to_fit(inputs, self.hyperparams) + self._input_column_names = self._training_inputs.columns + + + if len(self._training_indices) > 0: + self._fitted = True + else: + if self.hyperparams['error_on_no_input']: + raise RuntimeError("No input columns were selected") + self.logger.warn("No input columns were selected") + + if not self._fitted: + raise PrimitiveNotFittedError("Primitive not fitted.") + + sk_inputs = inputs + if self.hyperparams['use_semantic_types']: + sk_inputs = inputs.iloc[:, self._training_indices] + output_columns = [] + if len(self._training_indices) > 0: + sk_output = self._clf.produce(sk_inputs) + if sparse.issparse(sk_output): + sk_output = sk_output.toarray() + outputs = self._wrap_predictions(inputs, sk_output) + + if len(outputs.columns) == len(self._input_column_names): + outputs.columns = self._input_column_names + output_columns = [outputs] + + else: + if self.hyperparams['error_on_no_input']: + raise RuntimeError("No input columns were selected") + self.logger.warn("No input columns were selected") + + outputs = base_utils.combine_columns(return_result=self.hyperparams['return_result'], + add_index_columns=self.hyperparams['add_index_columns'], + inputs=inputs, column_indices=self._training_indices, + columns_list=output_columns) + #print(outputs) + #CallResult(outputs) + #print("___") + print(outputs.columns) + #outputs.columns = [str(x) for x in outputs.columns] + + return CallResult(outputs) + + # assert isinstance(inputs, container.DataFrame), type(container.DataFrame) + # _, self._columns_to_produce = self._get_columns_to_fit(inputs, self.hyperparams) + + # #print("columns_to_produce ", self._columns_to_produce) + + # outputs = inputs + # if len(self._columns_to_produce) > 0: + # for col in self.hyperparams['use_columns']: + # output = self._clf.produce(inputs.iloc[ : ,col]) + + # outputs = pd.concat((outputs, pd.DataFrame({inputs.columns[col]+'_matrix_profile': output[:,0], + # inputs.columns[col]+'_matrix_profile_indices': output[:,1], + # inputs.columns[col]+'_left_matrix_profile_indices': output[:,2], + # inputs.columns[col]+'_right_matrix_profile_indices': output[:,3]})), axis = 1) + + # else: + # if self.hyperparams['error_on_no_input']: + # raise RuntimeError("No input columns were selected") + # self.logger.warn("No input columns were selected") + + # #print(outputs) + # self._update_metadata(outputs) + + # return base.CallResult(outputs) + + + + def _update_metadata(self, outputs): + outputs.metadata = outputs.metadata.generate(outputs) + + @classmethod + def _get_columns_to_fit(cls, inputs: Inputs, hyperparams: Hyperparams): + """ - Fit model with training data. - Args: - *: Container DataFrame. Time series data up to fit. - Returns: - None + Select columns to fit. + Args: + inputs: Container DataFrame + hyperparams: d3m.metadata.hyperparams.Hyperparams + + Returns: + list + """ - return super().fit() - def produce(self, *, inputs: Inputs, timeout: float = None, iterations: int = None) -> CallResult[Outputs]: + if not hyperparams['use_semantic_types']: + return inputs, list(range(len(inputs.columns))) + + inputs_metadata = inputs.metadata + + + + def can_produce_column(column_index: int) -> bool: + return cls._can_produce_column(inputs_metadata, column_index, hyperparams) + + columns_to_produce, columns_not_to_produce = base_utils.get_columns_to_use(inputs_metadata, + use_columns=hyperparams['use_columns'], + exclude_columns=hyperparams['exclude_columns'], + can_use_column=can_produce_column) + + """ - Process the testing data. - Args: - inputs: Container DataFrame. Time series data up to outlier detection. + Encountered error: when hyperparams['use_columns'] = (2,3) and hyperparams['exclude_columns'] is (1,2) + columns_to_produce is still [2] + """ + return inputs.iloc[:, columns_to_produce], columns_to_produce + + + @classmethod + def _can_produce_column(cls, inputs_metadata: metadata_base.DataMetadata, column_index: int, hyperparams: Hyperparams) -> bool: - Returns: - Container DataFrame - 1 marks Outliers, 0 marks normal. """ - return super().produce(inputs=inputs, timeout=timeout, iterations=iterations) - def get_params(self) -> Params: + Output whether a column can be processed. + Args: + inputs_metadata: d3m.metadata.base.DataMetadata + column_index: int + + Returns: + bool + """ - Return parameters. + + column_metadata = inputs_metadata.query((metadata_base.ALL_ELEMENTS, column_index)) + + accepted_structural_types = (int, float, np.integer, np.float64) #changed numpy to np + accepted_semantic_types = set() + accepted_semantic_types.add("https://metadata.datadrivendiscovery.org/types/Attribute") + + # print(column_metadata) + # print(column_metadata['structural_type'], accepted_structural_types) + + if not issubclass(column_metadata['structural_type'], accepted_structural_types): + return False + + semantic_types = set(column_metadata.get('semantic_types', [])) + + # print(column_metadata) + # print(semantic_types, accepted_semantic_types) + + if len(semantic_types) == 0: + cls.logger.warning("No semantic types found in column metadata") + return False + + # Making sure all accepted_semantic_types are available in semantic_types + if len(accepted_semantic_types - semantic_types) == 0: + return True + + return False + + def _wrap_predictions(self, inputs: Inputs, predictions: ndarray) -> Outputs: + + """ + + Wrap predictions into dataframe Args: - None + inputs: Container Dataframe + predictions: array-like data (n_samples, n_features) Returns: - class Params + Dataframe + + """ + + outputs = d3m_dataframe(predictions, generate_metadata=True) + target_columns_metadata = self._add_target_columns_metadata(outputs.metadata, self.hyperparams, self.primitiveNo) + outputs.metadata = self._update_predictions_metadata(inputs.metadata, outputs, target_columns_metadata) + return outputs + + + + @classmethod + def _update_predictions_metadata(cls, inputs_metadata: metadata_base.DataMetadata, outputs: Optional[Outputs], + target_columns_metadata: List[OrderedDict]) -> metadata_base.DataMetadata: + """ - return super().get_params() - def set_params(self, *, params: Params) -> None: + Updata metadata for selected columns. + Args: + inputs_metadata: metadata_base.DataMetadata + outputs: Container Dataframe + target_columns_metadata: list + + Returns: + d3m.metadata.base.DataMetadata + + """ + + outputs_metadata = metadata_base.DataMetadata().generate(value=outputs) + + for column_index, column_metadata in enumerate(target_columns_metadata): + column_metadata.pop("structural_type", None) + outputs_metadata = outputs_metadata.update_column(column_index, column_metadata) + + return outputs_metadata + + + @classmethod + def _add_target_columns_metadata(cls, outputs_metadata: metadata_base.DataMetadata, hyperparams, primitiveNo): """ - Set parameters for outlier detection. + Add target columns metadata Args: - params: class Params + outputs_metadata: metadata.base.DataMetadata + hyperparams: d3m.metadata.hyperparams.Hyperparams Returns: - None + List[OrderedDict] """ - super().set_params(params=params) + outputs_length = outputs_metadata.query((metadata_base.ALL_ELEMENTS,))['dimension']['length'] + target_columns_metadata: List[OrderedDict] = [] + for column_index in range(outputs_length): + column_name = "{0}{1}_{2}".format(cls.metadata.query()['name'], primitiveNo, column_index) + column_metadata = OrderedDict() + semantic_types = set() + semantic_types.add(hyperparams["return_semantic_type"]) + column_metadata['semantic_types'] = list(semantic_types) + + column_metadata["name"] = str(column_name) + target_columns_metadata.append(column_metadata) + return target_columns_metadata diff --git a/tods/tests/test_MatrixProfile.py b/tods/tests/test_MatrixProfile.py index 0f3b859..d23f4a3 100644 --- a/tods/tests/test_MatrixProfile.py +++ b/tods/tests/test_MatrixProfile.py @@ -15,7 +15,7 @@ class MatrixProfileTest(unittest.TestCase): columns=['a', 'b', 'c'], generate_metadata=True) - print(main) + #print(main) self.assertEqual(utils.to_json_structure(main.metadata.to_internal_simple_structure()), [{