def __init__(self, xs, ys, args, xs_pair=None, moco=True): if moco: assert xs_pair is not None self.xs = xs self.xs_pair = xs_pair self.ys = ys self.is_moco = moco self.sample_len = len(self.xs[0]) if args.augment_type == 'warp': self.aug_for_query_moco = ( TimeWarp(seed=10) * 1 # random time warping ) self.aug_for_key_moco = ( TimeWarp(seed=20) * 1 # random time warping ) self.aug_train = ( TimeWarp(seed=30) * 1 # random time warping ) elif args.augment_type == 'noise': self.aug_for_query_moco = (AddNoise(scale=0.01, seed=10)) self.aug_for_key_moco = (AddNoise(scale=0.01, seed=20)) self.aug_train = (AddNoise(scale=0.01, seed=30)) elif args.augment_type == 'drift': self.aug_for_query_moco = (Drift(max_drift=0.7, n_drift_points=5, seed=10)) self.aug_for_key_moco = (Drift(max_drift=0.7, n_drift_points=5, seed=20)) self.aug_train = (Drift(max_drift=0.7, n_drift_points=5, seed=30)) elif args.augment_type == 'crop': crop_size = int(self.sample_len * 0.05) self.aug_for_query_moco = (Crop(size=crop_size, seed=10)) self.aug_for_key_moco = (Crop(size=crop_size, seed=20)) self.aug_train = (Crop(size=crop_size, seed=30)) elif args.augment_type == 'dropout': self.aug_for_query_moco = (Dropout(p=0.1, fill=0, seed=10)) self.aug_for_key_moco = (Dropout(p=0.1, fill=0, seed=20)) self.aug_train = (Dropout(p=0.1, fill=0, seed=30)) elif args.augment_type == 'dropout_0.2': self.aug_for_query_moco = (Dropout(p=0.2, fill=0, seed=10)) self.aug_for_key_moco = (Dropout(p=0.2, fill=0, seed=20)) self.aug_train = (Dropout(p=0.2, fill=0, seed=30)) if self.is_moco: self.d_aug_query = self.aug_for_query_moco.augment(xs) self.d_aug_key = self.aug_for_key_moco.augment(xs_pair) else: self.d_aug_train = self.aug_train.augment(xs)
def test_pipe(): augmenter = ( AddNoise() * 2 @ 0.5 + (Crop(size=int(T / 2)) * 2 + Drift()) + (Dropout() @ 0.5 + Pool()) + Quantize() * 2 ) augmenter.augment(X1) augmenter.augment(X1, Y1) augmenter.augment(X2) augmenter.augment(X2, Y2) augmenter.augment(X2, Y3) augmenter.augment(X3) augmenter.augment(X3, Y2) augmenter.augment(X3, Y3) augmenter.summary() assert len(augmenter) == 6 exchange = Resize(size=int(T / 2)) * 2 @ 0.5 augmenter[3] = exchange assert augmenter[3] is exchange exchange.resize = int(T / 3) exchange.repeats = 3 exchange.prob = 0.4 assert isinstance(augmenter[3], Resize) assert augmenter[3].resize == int(T / 3) assert augmenter[3].repeats == 3 assert augmenter[3].prob == 0.4
def augment_tsaug(filename): y, sr = librosa.load(filename, mono=False) duration = int(librosa.core.get_duration(y, sr)) print(y.shape) # y=np.expand_dims(y.swapaxes(0,1), 0) # N second splice between 1 second to N-1 secondsd splice = random.randint(1, duration - 1) my_augmenter = ( Crop(size=sr * splice) * 5 # random crop subsequences of splice seconds + AddNoise(scale=(0.01, 0.05)) @ 0.5 # with 50% probability, add random noise up to 1% - 5% + Dropout( p=0.1, fill=0, size=[int(0.001 * sr), int(0.01 * sr), int(0.1 * sr)] ) # drop out 10% of the time points (dropped out units are 1 ms, 10 ms, or 100 ms) and fill the dropped out points with zeros ) y_aug = my_augmenter.augment(y) newfile = 'tsaug_' + filename sf.write(newfile, y_aug.T, sr) return [newfile]
def mixmatch_batch(batch, batch_unlabeled, model, output_transform, K, T, beta): features_labeled = batch['features'].to(device) targets_labeled = batch['targets'].to(device) features_unlabeled = batch_unlabeled[0] # ['features'] # print("!!!!") from tsaug import TimeWarp, Crop, Quantize, Drift, Reverse, AddNoise my_augmenter = ( # TimeWarp() # + Crop(size=155) # + Quantize(n_levels=[10, 20, 30]) AddNoise(scale=0.001) # + Drift(max_drift=(0.01, 3)) # + Reverse() ) # new = np.zeros((16,155)) new = None num = 0 for u in features_unlabeled: # print(len(u.numpy().tolist())) x = my_augmenter.augment(u.numpy()).reshape((1, u.shape[0])) if new is None: new = x else: new = np.concatenate((new, x)) num = num + 1 features_unlabeled = torch.from_numpy(new.astype(np.float32)).to(device) # print(features_unlabeled.shape) # print(features_labeled.shape) targets_unlabeled = guess_targets(features_unlabeled, model, output_transform, K, T).to(device) # print("!!") # print(features_unlabeled.shape) # print(targets_unlabeled.shape) indices = torch.randperm(len(features_labeled) + len(features_unlabeled)) features_W = torch.cat((features_labeled, features_unlabeled), dim=0)[indices] # print(targets_labeled.shape,"!!",targets_unlabeled.shape) targets_W = torch.cat((targets_labeled, targets_unlabeled), dim=0)[indices] features_X, targets_X = mixup_samples(features_labeled, targets_labeled, features_W[:len(features_labeled)], targets_W[:len(features_labeled)], beta) features_U, targets_U = mixup_samples(features_unlabeled, targets_unlabeled, features_W[len(features_labeled):], targets_W[len(features_labeled):], beta) return dict( features=torch.cat((features_X, features_U), dim=0), targets=torch.cat((targets_X, targets_U), dim=0), )
def __init__(self, d, l, batch_size): self.data = d self.label = l self.now = 0 self.len = d.shape[0] self.batch_size = batch_size self.num_workers = 0 self.my_augmenter = ( # TimeWarp() # + Crop(size=155) # + Quantize(n_levels=[10, 20, 30]) # + Drift(max_drift=(0.1, 0.5)) # + Reverse() AddNoise(scale=0.001) )
from tsaug import ( AddNoise, Convolve, Crop, Drift, Dropout, Pool, Quantize, Resize, Reverse, TimeWarp, ) augmenters = [ AddNoise(), Convolve(size=(7, 10)) * 10, Crop(size=10), Drift(), Dropout(), Pool(size=[2, 4, 8]) * 10, Quantize(n_levels=[10, 20, 30]) * 10, Reverse() @ 0.5 * 10, TimeWarp(), ] N = 10 T = 1000 C = 3 L = 2 M = 4
from tsaug import TimeWarp, Drift, Pool, AddNoise # , Crop, Quantize, Drift, Reverse import numpy as np from wfdb.processing import (normalize_bound) my_augmenter = (TimeWarp(n_speed_change=1, prob=0.33) + Drift(max_drift=(0.05, 0.3)) + Pool(prob=0.2) + AddNoise(prob=0.2)) def tsaug_generator(X_all, y_all, batch_size): """ Generate Time Series data with sequence labels Data generator that yields training data as batches. 1. Randomly selects one sample from time series signals 2. Applies time series augmentations to X and Y 3. Normalizes result for X data 4. Reshapes data into correct format for training Parameters ---------- X_all : 3D numpy array (N, seqlen, features=1) y_all : 3D numpy array (binary labels for my case) (N, seqlen, classes=1) batch_size : int Number of training examples in the batch Yields ------
N = 10 T = 100 C = 3 L = 2 M = 4 X1 = np.random.uniform(size=T) X2 = np.random.uniform(size=(N, T)) X3 = np.random.uniform(size=(N, T, C)) Y1 = np.random.choice(2, size=T).astype(int) Y2 = np.random.choice(2, size=(N, T)).astype(int) Y3 = np.random.choice(2, size=(N, T, L)).astype(int) augmenters = [ AddNoise(repeats=M, prob=0.5, seed=0), AddNoise(loc=(-1.0, 1.0), scale=(0.1, 0.2), seed=0), AddNoise(loc=[-1.0, 1.0], scale=[0.1, 0.2], seed=0), AddNoise(distr="laplace", seed=0), AddNoise(distr="uniform", seed=0), AddNoise(kind="multiplicative", seed=0), AddNoise(per_channel=False, normalize=False, seed=0), Convolve(repeats=M, prob=0.5, seed=0), Convolve(window=["hann", "blackman", ("gaussian", 1)], seed=0), Convolve( window=["hann", "blackman", ("gaussian", 1)], per_channel=True, seed=0 ), Convolve(window=("gaussian", 1), seed=0), Convolve(size=(7, 11), seed=0), Convolve(size=(7, 11), per_channel=True, seed=0), Convolve(size=[7, 11], seed=0),
from tsaug import AddNoise, Convolve, Drift, Pool, Quantize, Reverse, TimeWarp import numpy as np transformations = [ ( AddNoise(scale=0.01) ), ( Convolve(window="hann", size=10) ), ( Drift(max_drift=0.05, n_drift_points=4) ), ( Pool(size=2) ), ( Quantize(n_levels=10) ), ( Reverse() ), ( TimeWarp(n_speed_change=5, max_speed_ratio=3) ), ( TimeWarp() # time warping + Drift(max_drift=(0.05, 0.3)) @ 0.8 # with 80% probability, random drift the signal up to 5% - 30% + Reverse() @ 0.5 # with 50% probability, reverse the sequence ), ( Convolve(window="hann", size=10) + Pool(size=2) + AddNoise() ), ( Pool(size=2) + TimeWarp(n_speed_change=5, max_speed_ratio=3) + AddNoise() + Reverse() ), ]