def load_basic_motions(split=None, return_X_y=True, return_type=None): """ Load the BasicMotions time series classification problem and returns X and y. This is an equal length multivariate time series classification problem. It loads a 4 class classification problem with number of cases, n, where n = 80 (if split is None) or 40 (if split is "train"/"test") of series length m = 100. Parameters ---------- split: None or str{"train", "test"}, optional (default=None) Whether to load the train or test partition of the problem. By default it loads both. return_X_y: bool, optional (default=True) If True, returns (time series, target) separately as X and y instead of a single data structure. return_type: None or str{"numpy3d", "nested_univ"}, optional (default=None). Controls the returned data structure. Returns ------- X: The time series data for the problem. If return_type is either "numpy2d"/"numpyflat", it returns 2D numpy array of shape (n,m), if "numpy3d" it returns 3D numpy array of shape (n,6,m) and if "nested_univ" or None it returns a nested pandas DataFrame of shape (n,6), where each cell is a pd.Series of length m. y: (optional) numpy array shape (n,1). The class labels for each case in X. If return_X_y is False, y is appended to X. Raises ------ ValueError if argument "numpy2d"/"numpyflat" is passed as return_type Notes ----- Dimensionality: multivariate, 6 Series length: 100 Train cases: 40 Test cases: 40 Number of classes: 4 The data was generated as part of a student project where four students performed four activities whilst wearing a smart watch. The watch collects 3D accelerometer and a 3D gyroscope It consists of four classes, which are walking, resting, running and badminton. Participants were required to record motion a total of five times, and the data is sampled once every tenth of a second, for a ten second period. Dataset details: http://www.timeseriesclassification.com/description.php?Dataset =BasicMotions """ name = "BasicMotions" if return_type == "numpy2d" or return_type == "numpyflat": raise ValueError( f"{name} loader: Error, attempting to load into a numpy2d " f"array, but cannot because it is a multivariate problem. Use " f"numpy3d instead") return _load_provided_dataset(name=name, split=split, return_X_y=return_X_y, return_type=return_type)
def load_arrow_head(split=None, return_X_y=True, return_type="nested_univ"): """ Load the ArrowHead time series classification problem and returns X and y. Parameters ---------- split: None or str{"train", "test"}, optional (default=None) Whether to load the train or test partition of the problem. By default it loads both. return_X_y: bool, optional (default=True) If True, returns (features, target) separately instead of a single dataframe with columns for features and the target. Returns ------- X: pd.DataFrame with m rows and c columns The time series data for the problem with m cases and c dimensions y: numpy array The class labels for each case in X Examples -------- >>> from sktime.datasets import load_arrow_head >>> X, y = load_arrow_head() Notes ----- Dimensionality: univariate Series length: 251 Train cases: 36 Test cases: 175 Number of classes: 3 The arrowhead data consists of outlines of the images of arrowheads. The shapes of the projectile points are converted into a time series using the angle-based method. The classification of projectile points is an important topic in anthropology. The classes are based on shape distinctions such as the presence and location of a notch in the arrow. The problem in the repository is a length normalised version of that used in Ye09shapelets. The three classes are called "Avonlea", "Clovis" and "Mix"." Dataset details: http://timeseriesclassification.com/description.php ?Dataset=ArrowHead """ name = "ArrowHead" return _load_provided_dataset(name=name, split=split, return_X_y=return_X_y, return_type=return_type)
def load_unit_test(split=None, return_X_y=True, return_type=None): """ Load UnitTest data. This is an equal length univariate time series classification problem. It is a stripped down version of the ChinaTown problem that is used in correctness tests for classification. It loads a two class classification problem with number of cases, n, where n = 42 (if split is None) or 20/22 (if split is "train"/"test") of series length m = 24 Parameters ---------- split: None or str{"train", "test"}, optional (default=None) Whether to load the train or test partition of the problem. By default it loads both. return_X_y: bool, optional (default=True) If True, returns (features, target) separately instead of a concatenated data structure. return_type: None or str{"numpy2d", "numpyflat", "numpy3d", "nested_univ"}, optional (default=None). Controls the returned data structure. Returns ------- X: The time series data for the problem. If return_type is either "numpy2d"/"numpyflat", it returns 2D numpy array of shape (n,m), if "numpy3d" it returns 3D numpy array of shape (n,1,m) and if "nested_univ" or None it returns a nested pandas DataFrame of shape (n,1), where each cell is a pd.Series of length m. y: (optional) numpy array shape (n,1). The class labels for each case in X. If return_X_y is False, y is appended to X. Examples -------- >>> from sktime.datasets import load_unit_test >>> X, y = load_unit_test() Details ------- This is the Chinatown problem with a smaller test set, useful for rapid tests. Dimensionality: univariate Series length: 24 Train cases: 20 Test cases: 22 (full dataset has 345) Number of classes: 2 See http://timeseriesclassification.com/description.php?Dataset=Chinatown for the full dataset """ name = "UnitTest" return _load_provided_dataset(name, split, return_X_y, return_type)
def load_basic_motions(split=None, return_X_y=True, return_type="nested_univ"): """ Load the BasicMotions time series classification problem and returns X and y. Parameters ---------- split: None or str{"train", "test"}, optional (default=None) Whether to load the train or test partition of the problem. By default it loads both. return_X_y: bool, optional (default=True) If True, returns (features, target) separately instead of a single dataframe with columns for features and the target. Returns ------- X: pandas DataFrame with m rows and c columns The time series data for the problem with m cases and c dimensions y: numpy array The class labels for each case in X Notes ----- Dimensionality: multivariate, 6 Series length: 100 Train cases: 40 Test cases: 40 Number of classes: 4 The data was generated as part of a student project where four students performed four activities whilst wearing a smart watch. The watch collects 3D accelerometer and a 3D gyroscope It consists of four classes, which are walking, resting, running and badminton. Participants were required to record motion a total of five times, and the data is sampled once every tenth of a second, for a ten second period. Dataset details: http://www.timeseriesclassification.com/description.php?Dataset =BasicMotions """ name = "BasicMotions" return _load_provided_dataset(name=name, split=split, return_X_y=return_X_y, return_type=return_type)
def load_unit_test(split=None, return_X_y=True): """ Load UnitTest time series classification problem. This problem is a stripped down version of the ChinaTown problem that is used in correctness tests for classification. Parameters ---------- split: None or str{"train", "test"}, optional (default=None) Whether to load the train or test partition of the problem. By default it loads both. return_X_y: bool, optional (default=True) If True, returns (features, target) separately instead of a single dataframe with columns for features and the target. Returns ------- X: pandas DataFrame with m rows and c columns The time series data for the problem with m cases and c dimensions y: numpy array The class labels for each case in X Details ------- This is the Chinatown problem with a smaller test set, useful for rapid tests. See http://timeseriesclassification.com/description.php?Dataset=Chinatown for the full dataset Dimensionality: univariate Series length: 24 Train cases: 20 Test cases: 22 (full dataset has 345) Number of classes: 2 """ name = "UnitTest" return _load_provided_dataset(name, split, return_X_y)