def build_gunpoint(random_state=0, verbose=True, label_encoder=True): X_all, X_test, y_all, y_test = load_gunpoint(return_X_y=True) X_all = X_all[:, :, np.newaxis] X_test = X_test[:, :, np.newaxis] if label_encoder: le = LabelEncoder() le.fit(y_all) y_all = le.transform(y_all) y_test = le.transform(y_test) if verbose: print("DATASET INFO:") print("X SHAPE: ", X_all.shape) print("y SHAPE: ", y_all.shape) unique, counts = np.unique(y_all, return_counts=True) print("\nCLASSES BALANCE") for i, label in enumerate(unique): print(label, ": ", round(counts[i] / sum(counts), 2)) # BLACKBOX/EXPLANATION SETS SPLIT X_train, X_val, y_train, y_val = train_test_split( X_all, y_all, test_size=0.2, stratify=y_all, random_state=random_state ) X_exp_train = X_train.copy() y_exp_train = y_train.copy() X_exp_val = X_val.copy() y_exp_val = y_val.copy() X_exp_test = X_test.copy() y_exp_test = y_test.copy() warnings.warn("Blackbox and Explanation sets are the same") if verbose: print("\nSHAPES:") print("BLACKBOX TRAINING SET: ", X_train.shape) print("BLACKBOX VALIDATION SET: ", X_val.shape) print("BLACKBOX TEST SET: ", X_test.shape) print("EXPLANATION TRAINING SET: ", X_exp_train.shape) print("EXPLANATION VALIDATION SET: ", X_exp_val.shape) print("EXPLANATION TEST SET: ", X_exp_test.shape) print("\nBlackbox and Explanation sets are the same!") return (X_train, y_train, X_val, y_val, X_test, y_test, X_exp_train, y_exp_train, X_exp_val, y_exp_val, X_exp_test, y_exp_test)
For Gun-Draw the actors have their hands by their sides. They draw a replicate gun from a hip-mounted holster, point it at a target for approximately one second, then return the gun to the holster, and their hands to their sides. For Point the actors have their gun by their sides. They point with their index fingers to a target for approximately one second, and then return their hands to their sides. For both classes, we tracked the centroid of the actor's right hands in both X- and Y-axes, which appear to be highly correlated. The data in the archive is just the X-axis. It is implemented as :func:`pyts.datasets.load_gunpoint`. """ import matplotlib.pyplot as plt from pyts.datasets import load_gunpoint X_train, X_test, y_train, y_test = load_gunpoint(return_X_y=True) n_samples_per_plot = 3 plt.figure(figsize=(12, 8)) for i, ( X, y, set_, class_, ) in enumerate( zip([X_train, X_train, X_test, X_test], [y_train, y_train, y_test, y_test], ['Training', 'Training', 'Test', 'Test'], [1, 2, 1, 2])): plt.subplot(2, 2, i + 1) for i in range(n_samples_per_plot):
set of values from consecutive time points. The distance between a shapelet and a time series is defined as the minimum of the distances between this shapelet and all the shapelets of same length extracted from this time series. The most discriminative shapelets are selected. This example illustrates the transformation of this algorithm and highlights the most discriminative shapelets that have been selected. It is implemented as :class:`pyts.transformation.ShapeletTransform`. """ import numpy as np import matplotlib.pyplot as plt from pyts.datasets import load_gunpoint from pyts.transformation import ShapeletTransform # Toy dataset X_train, _, y_train, _ = load_gunpoint(return_X_y=True) # Shapelet transformation st = ShapeletTransform(window_sizes=[12, 24, 36, 48], random_state=42, sort=True) X_new = st.fit_transform(X_train, y_train) # Visualize the four most discriminative shapelets plt.figure(figsize=(6, 4)) for i, index in enumerate(st.indices_[:4]): idx, start, end = index plt.plot(X_train[idx], color='C{}'.format(i), label='Sample {}'.format(idx)) plt.plot(np.arange(start, end),
""" @author: masterqkk, [email protected] Environment: python: 3.6 Pandas: 1.0.3 matplotlib: 3.2.1 """ import pickle import numpy as np import matplotlib.pyplot as plt import scipy.signal as scisig from mpl_toolkits.axes_grid1 import make_axes_locatable from pyts.datasets import load_gunpoint if __name__ == '__main__': X, _, _, _ = load_gunpoint(return_X_y=True) fs = 10e3 # sampling frequency N = 1e5 # 10 s 1signal amp = 2 * np.sqrt(2) time = np.arange(N) / float(fs) mod = 500 * np.cos(2 * np.pi * 0.25 * time) carrier = amp * np.sin(2 * np.pi * 3e3 * time + mod) noise_power = 0.01 * fs / 2 noise = np.random.normal(loc=0.0, scale=np.sqrt(noise_power), size=time.shape) noise *= np.exp(-time / 5) x = carrier + noise # signal with noise per_seg_length = 1000 # window length
from sklearn.neighbors import KNeighborsClassifier import pandas as pd import sys import matplotlib.pyplot as plt from sklearn.cluster import KMeans np.set_printoptions(threshold=sys.maxsize) #print("shape is", data_train.shape) # km = KMeans( # n_clusters=3, init='random', # n_init=10, max_iter=300, # tol=1e-04, random_state=0 # ) # y_km = km.fit(data_train) instances = readData("./venezia/Punta_Salute_1983_2015/Punta_Salute_2015.csv") data_train, data_test, target_train, target_test = load_gunpoint(return_X_y=True) window_size, word_size = 50, 5 bow = BagOfWords(window_size=window_size, word_size=word_size, window_step=window_size, numerosity_reduction=False) X_bow = bow.transform(data_train) test_bow = bow.transform(data_test) frequencyDictListX = [] frequencyDictListTest = [] for i in range(len(X_bow)): frequencyDict = {}
if __name__ == '__main__': import timeit import numpy as np import pandas as pd import datetime as dt from ast import literal_eval from pyts.datasets import load_gunpoint from sklearn.metrics import accuracy_score, recall_score, precision_score from sktime_dl.deeplearning import CNNClassifier, FCNClassifier, MLPClassifier, \ InceptionTimeClassifier, ResNetClassifier, EncoderClassifier X_train, X_test, y_train, y_test = load_gunpoint( return_X_y=True) # get gunpoint data from pyts # as of the date of this publication, please note the following issue needs to be fixed mannually before running # https://github.com/sktime/sktime-dl/issues/79 ''' def prepare_for_sktime_dl(data): df = pd.DataFrame(data) cols = df.columns df['dim_0'] = df[cols].apply(lambda row: ', '.join(row.values.astype(str)), axis=1) df['dim_0'] = ['[' + i + ']' for i in df.dim_0 ] df['dim_0'] = df['dim_0'].apply(literal_eval) return df.drop(columns=cols)''' X_train = np.reshape(X_train, X_train.shape + (1, )) X_test = np.reshape(X_test, X_test.shape + (1, ))
"""Testing for base classes.""" # Author: Johann Faouzi <*****@*****.**> # License: BSD-3-Clause import numpy as np import pytest from sklearn.base import clone from pyts.classification import SAXVSM from pyts.datasets import load_gunpoint, load_basic_motions from pyts.multivariate.image import JointRecurrencePlot from pyts.multivariate.classification import MultivariateClassifier from pyts.approximation import SymbolicFourierApproximation X_uni, _, y_uni, _ = load_gunpoint(return_X_y=True) X_multi, _, y_multi, _ = load_basic_motions(return_X_y=True) @pytest.mark.parametrize('estimator, X, y', [ (SymbolicFourierApproximation(n_bins=2), X_uni, None), (SymbolicFourierApproximation(n_bins=2, strategy='entropy'), X_uni, y_uni) ]) def test_univariate_transformer_mixin(estimator, X, y): sfa_1 = clone(estimator) sfa_2 = clone(estimator) np.testing.assert_array_equal(sfa_1.fit_transform(X, y), sfa_2.fit(X, y).transform(X)) @pytest.mark.parametrize('estimator, X, y',
def getData(self,set_type): ################### ## Data Generation ################### if set_type == "generator": #Settings windowLength = 1 samplesPerWindow = 100 n_classes = 6 n_windows = 1000 Gen = ImbalancedDataGenerator(n_samples= samplesPerWindow,resolution = windowLength/samplesPerWindow,SNR_dB = 50, variation = 1, n_classes=n_classes, useseed = False, seed = 5) windows_pool, windows_test, y_pool, y_test = Gen.GeneratePool(n_windows) class_names = Gen.class_names ## Generator ##Data shape #n_samples = 100 #samples of 1 window (1 window exists of X samples) #resolution = 0.01 # time step between 2 samples #SNR_dB = 50 # Signal to Noise ration in dB #variation = 1 # 0 to 1 (0 to 100%), higher values possible #Gen = Datagenerator2.DataGenerator2(n_samples= n_samples,resolution = resolution,SNR_dB = SNR_dB, variation = variation, n_classes=30, useseed = False, seed = 5) # size var , length var, n classes #if obj.fast_mode and not obj.singleErrorOutput: #x_pool, x_test, y_pool, y_test = obj.GeneratePool(obj.n_windows) #train_windows = None #test_windows = None #else: # windows_pool, windows_test, y_pool, y_test = Gen.GeneratePool(obj.n_windows) # pass elif set_type == "GunPoint": ## Gunpoint Dataset windowLength = 1 #unspecified ! samplesPerWindow = 50 n_classes = 2 n_windows = 50 from pyts.datasets import load_gunpoint windows_pool, windows_test, y_pool, y_test = load_gunpoint(return_X_y=True) class_names = ['gun', 'point'] if y_pool.min() > 0 or y_test.min() > 0 : print("1st class is decoded as zero (was 1)") y_pool -= 1 #class 1 = class 0 y_test -= 1 elif set_type == "Crop": #http://www.timeseriesclassification.com/description.php?Dataset=Crop windowLength = 1 #unspecified ! samplesPerWindow = 46 n_classes = 24 n_windows = 7200 from sktime.utils.load_data import load_from_tsfile_to_dataframe windows_pool, y_pool = load_from_tsfile_to_dataframe("/home/tob/Datasets/Crop_TRAIN.ts") windows_test, y_test = load_from_tsfile_to_dataframe("/home/tob/Datasets/Crop_TEST.ts") windows_pool, windows_test, y_pool, y_test = self.postProcessSetfromTSCcom(windows_pool, windows_test, y_pool, y_test,samplesPerWindow) class_names = ['Class 1', 'Class 2', 'Class 3', 'Class 4', 'Class 5', 'Class 6', 'Class 7', 'Class 8', 'Class 9', 'Class 10', 'Class 11', 'Class 12', 'Class 13', 'Class 14', 'Class 15', 'Class 16', 'Class 17', 'Class 18', 'Class 19', 'Class 20', 'Class 21', 'Class 22', 'Class 23', 'Class 24'] elif set_type == "FaceAll": #http://www.timeseriesclassification.com/description.php?Dataset=FaceAll windowLength = 1 #unspecified ! samplesPerWindow = 131 n_classes = 14 n_windows = 560 from sktime.utils.load_data import load_from_tsfile_to_dataframe windows_pool, y_pool = load_from_tsfile_to_dataframe("/home/tob/Datasets/FaceAll_TRAIN.ts") windows_test, y_test = load_from_tsfile_to_dataframe("/home/tob/Datasets/FaceAll_TEST.ts") windows_pool, windows_test, y_pool, y_test = postProcessSetfromTSCcom(windows_pool, windows_test, y_pool, y_test,samplesPerWindow) class_names = ['Student 1', 'Student 2', 'Student 3', 'Student 4', 'Student 5', 'Student 6', 'Student 7', 'Student 8', 'Student 9', 'Student 10', 'Student 11', 'Student 12', 'Student 13', 'Student 14'] elif set_type == "InsectWingbeat": #http://www.timeseriesclassification.com/description.php?Dataset=InsectWingbeat windowLength = 1 #unspecified ! samplesPerWindow = 30 n_classes = 10 n_windows = 30000 from sktime.utils.load_data import load_from_tsfile_to_dataframe windows_pool, y_pool = load_from_tsfile_to_dataframe("/home/tob/Datasets/InsectWingbeat_TRAIN.ts") windows_test, y_test = load_from_tsfile_to_dataframe("/home/tob/Datasets/InsectWingbeat_TEST.ts") windows_pool, windows_test, y_pool, y_test = postProcessSetfromTSCcom(windows_pool, windows_test, y_pool, y_test,samplesPerWindow) class_names = ['Insect 1', 'Insect 2', 'Insect 3', 'Insect 4', 'Insect 5', 'Insect 6', 'Insect 7', 'Insect 8', 'Insect 9', 'Insect 10'] #make the Dataset imbalanced (class 0 to class 4 matters, class 5 don't care: exists of all other classes) #Setting n_classes = 6 y_pool, y_test = np.clip(y_pool,0,n_classes-1), np.clip(y_test,0,n_classes-1) class_names = class_names[:n_classes] class_names[-1] = "don't care" print("imbalanced classes:") print(class_names) #reshaping for NN #if useNeuralNet == True: # X = np.reshape(X, (X.shape[0],1,X.shape[1])) # Y = np.reshape(Y, (Y.shape[0], 1)) # Y = to_categorical(Y,num_classes=self.n_classes) ## USE CASE 1 POOL : test = complete pool #x_test = np.copy(x_pool) #y_test = np.copy(y_pool) #test_windows = np.copy(train_windows) #obj.visualizeBoss(x_pool,y_pool) #Testing #print("Gen+ FST " + str(time.time() -test )) #End of Data Generation return windows_pool, windows_test, y_pool, y_test, class_names, windowLength, n_classes, samplesPerWindow