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()
),
]