def grid_search(train, grid_params, module, loss, outpath):
net = NeuralNet(module,
loss,
optimizer=torch.optim.Adam,
max_epochs=MAX_EPOCHS,
device=DEVICE,
iterator_train__shuffle=False,
callbacks=[
EarlyStopping("valid_loss",
lower_is_better=True,
patience=PATIENCE)
],
train_split=CVSplit(5, random_state=SEED)) #, verbose=0)
kf = KFold(n_splits=5, shuffle=False, random_state=SEED)
gs = GridSearchCV(net,
grid_params,
cv=kf,
refit=True,
scoring=loss(),
verbose=10)
grid_res = gs.fit(SliceDataset(train), train.y)
df = pd.DataFrame(grid_res.cv_results_)
# Adding some meta info
df["param_feature_set"] = FLEVEL
df["param_overlapping"] = WINDOW_OVERLAPPING
df["param_context_len"] = CONTEXT_LEN
df["param_discretized"] = DISCRETIZED
df["param_module"] = module.__name__
fname = f"gridsearch_{FLEVEL}_{CONTEXT_LEN}_{WINDOW_OVERLAPPING}_{DISCRETIZED}_{module.__name__}.pkl"
df.to_pickle(outpath / fname)
def load_extras(self):
callbacks = []
load_best_loss = train_end_load_best_loss(self.identifier)
self.split = CVSplit(cv=self.val_split) if self.val_split != 0 else 0
metrics = evaluator(
self.val_split,
self.config["optim"].get("metric", "mae"),
self.identifier,
self.forcetraining,
)
callbacks.extend(metrics)
if not self.debug:
callbacks.append(load_best_loss)
scheduler = self.config["optim"].get("scheduler", None)
if scheduler:
scheduler = LRScheduler(scheduler,
**self.config["optim"]["scheduler_params"])
callbacks.append(scheduler)
if self.config["cmd"].get("logger", False):
from skorch.callbacks import WandbLogger
callbacks.append(
WandbLogger(
self.wandb_run,
save_model=False,
keys_ignored="dur",
))
self.callbacks = callbacks
def test_cvsplit_deprecation(self):
from skorch.dataset import CVSplit
with pytest.warns(
DeprecationWarning,
match="is deprecated, use the new name ValidSplit instead",
):
CVSplit()
def test_regular(device):
"""
Tests the LSTMTimeSeriesPredictor fitting
"""
cuda_check(device)
start = time.time()
tsp = TimeSeriesPredictor(
BenchmarkLSTM(hidden_dim=16),
lr=1e-3,
lambda1=1e-8,
optimizer__weight_decay=1e-8,
iterator_train__shuffle=True,
early_stopping=EarlyStopping(patience=50),
max_epochs=250,
train_split=CVSplit(10),
optimizer=Adam,
device=device,
)
past_pattern_length = 24
future_pattern_length = 12
pattern_length = past_pattern_length + future_pattern_length
fsd = FlightSeriesDataset(pattern_length,
past_pattern_length,
pattern_length,
stride=1)
tsp.fit(fsd)
end = time.time()
elapsed = timedelta(seconds=end - start)
print(f"Fitting in {device} time delta: {elapsed}")
mean_r2_score = tsp.score(tsp.dataset)
print(f"Achieved R2 score: {mean_r2_score}")
assert mean_r2_score > -20
def validation_split(X, y):
""" Custom split is used to apply augmentation to the training set only """
splitter = CVSplit(cv=int(100 / early_stopping_val_percent),
random_state=RANDOM_STATE)
dataset_train, dataset_valid = splitter(X)
dataset_train = cls.AugmentedDataset(dataset_train)
return dataset_train, dataset_valid
def build_estimator(hyperparams, train_data, test=False):
device = 'cuda' if torch.cuda.is_available() else 'cpu'
# Extract info from training data
X, y, *_ = train_data
in_features = X.shape[1]
n_classes = len(np.unique(y))
n_samples = y.shape[0]
bal_weights = torch.from_numpy(
n_samples / (n_classes * np.bincount(y))).float().to(device)
callbacks = [
('f1_score_valid',
EpochScoring('f1' if n_classes == 2 else 'f1_macro',
name='valid_f1',
lower_is_better=False)),
('early_stopping',
EarlyStopping(monitor='valid_loss',
patience=5,
lower_is_better=True)),
(
'learning_rate_scheduler',
LRScheduler(
policy=lr_scheduler.ReduceLROnPlateau,
monitor='valid_loss',
# Following kargs are passed to the
# lr scheduler constructor
mode='min',
min_lr=1e-5)),
]
return NeuralNetClassifier(
NNModule,
criterion=nn.CrossEntropyLoss,
optimizer=torch.optim.SGD,
max_epochs=300,
iterator_train__shuffle=True, # Shuffle training data on each epoch
callbacks=callbacks,
device=device,
train_split=CVSplit(cv=5,
stratified=True,
random_state=RANDOM_STATE),
lr=hyperparams['lr'],
batch_size=hyperparams['batch_size'],
module__in_features=in_features,
module__n_classes=n_classes,
module__n_layers=hyperparams['n_layers'],
module__n_neuron_per_layer=hyperparams['n_neuron_per_layer'],
module__activation=getattr(F, hyperparams['activation']),
module__p_dropout=hyperparams['p_dropout'],
criterion__weight=bal_weights
if hyperparams['class_weight'] == 'balanced' else None,
optimizer__momentum=hyperparams['momentum'],
optimizer__weight_decay=hyperparams['weight_decay'],
optimizer__nesterov=True,
verbose=3,
iterator_train__num_workers=4,
iterator_valid__num_workers=4)
def __init__(
self,
module,
criterion,
optimizer=torch.optim.SGD,
lr=0.01,
gradient_clip_value=None,
gradient_clip_norm_type=2,
max_epochs=10,
batch_size=128,
iterator_train=DataLoader,
iterator_valid=DataLoader,
dataset=Dataset,
train_split=CVSplit(5),
callbacks=None,
cold_start=True,
verbose=1,
use_cuda=False,
**kwargs
):
self.module = module
self.criterion = criterion
self.optimizer = optimizer
self.lr = lr
self.max_epochs = max_epochs
self.batch_size = batch_size
self.iterator_train = iterator_train
self.iterator_valid = iterator_valid
self.dataset = dataset
self.train_split = train_split
self.callbacks = callbacks
self.cold_start = cold_start
self.verbose = verbose
self.use_cuda = use_cuda
self.gradient_clip_value = gradient_clip_value
self.gradient_clip_norm_type = gradient_clip_norm_type
history = kwargs.pop('history', None)
initialized = kwargs.pop('initialized_', False)
# catch arguments that seem to not belong anywhere
unexpected_kwargs = []
for key in kwargs:
if key.endswith('_'):
continue
if any(key.startswith(p) for p in self.prefixes_):
continue
unexpected_kwargs.append(key)
if unexpected_kwargs:
msg = ("__init__() got unexpected argument(s) {}."
"Either you made a typo, or you added new arguments "
"in a subclass; if that is the case, the subclass "
"should deal with the new arguments explicitely.")
raise TypeError(msg.format(', '.join(unexpected_kwargs)))
vars(self).update(kwargs)
self.history = history
self.initialized_ = initialized
def run_100(task, task_df, args, threshold):
reduce_lr = LRScheduler(
policy='ReduceLROnPlateau',
mode='min',
factor=0.5,
patience=1,
)
seeds = list(range(args.start_seed, args.start_seed + 100))
for seed in tqdm(seeds, desc=f'{task} Runs'):
logger.info(f"Spliting with seed {seed}")
checkpoint = Checkpoint(dirname=args.modeldir /
f'{task}_seed_{seed}', )
df = set_group_splits(task_df.copy(), group_col='hadm_id', seed=seed)
vectorizer = TfidfVectorizer(sublinear_tf=True,
ngram_range=(1, 2),
binary=True,
max_features=60_000)
x_train = vectorizer.fit_transform(
df.loc[(df['split'] == 'train')]['processed_note']).astype(
np.float32)
x_test = vectorizer.transform(
df.loc[(df['split'] == 'test')]['processed_note']).astype(
np.float32)
x_train = np.asarray(x_train.todense())
x_test = np.asarray(x_test.todense())
vocab_sz = len(vectorizer.vocabulary_)
y_train = df.loc[(df['split'] == 'train')][f'{task}_label'].to_numpy()
y_test = df.loc[(df['split'] == 'test')][f'{task}_label'].to_numpy()
clf = MLPModule(input_units=vocab_sz,
output_units=1,
hidden_units=args.hidden_dim,
num_hidden=1,
dropout=args.dropout_p,
squeeze_output=True)
net = NeuralNetBinaryClassifier(
clf,
max_epochs=args.max_epochs,
lr=args.lr,
device=args.device,
optimizer=optim.Adam,
optimizer__weight_decay=args.wd,
batch_size=args.batch_size,
verbose=1,
callbacks=[EarlyStopping, ProgressBar, checkpoint, reduce_lr],
train_split=CVSplit(cv=0.15, stratified=True),
iterator_train__shuffle=True,
threshold=threshold,
)
net.set_params(callbacks__valid_acc=None)
net.fit(x_train, y_train.astype(np.float32))
def __init__(self,
module,
*args,
criterion=torch.nn.NLLLoss,
train_split=CVSplit(5, stratified=True),
**kwargs):
super(NeuralNetClassifier, self).__init__(module,
*args,
criterion=criterion,
train_split=train_split,
**kwargs)
def test_net_input_is_scoring_input(
self, net_cls, module_cls, scoring_cls, data,
):
# Make sure that whatever data type is put in the network is
# received at the scoring side as well. For the caching case
# we only receive datasets.
import skorch
from skorch.dataset import CVSplit
import torch.utils.data.dataset
from torch.utils.data.dataset import Subset
class MyTorchDataset(torch.utils.data.dataset.TensorDataset):
def __init__(self, X, y):
super().__init__(
skorch.utils.to_tensor(X.reshape(-1, 1), device='cpu'),
skorch.utils.to_tensor(y, device='cpu'))
class MySkorchDataset(skorch.dataset.Dataset):
pass
rawsplit = lambda ds: (ds, ds)
cvsplit = CVSplit(2, random_state=0)
def split_ignore_y(ds, y):
return rawsplit(ds)
table = [
# Test a split where type(input) == type(output) is guaranteed
(data, split_ignore_y, np.ndarray, False),
(data, split_ignore_y, skorch.dataset.Dataset, True),
((MyTorchDataset(*data), None), rawsplit, MyTorchDataset, False),
((MyTorchDataset(*data), None), rawsplit, MyTorchDataset, True),
((MySkorchDataset(*data), None), rawsplit, np.ndarray, False),
((MySkorchDataset(*data), None), rawsplit, MySkorchDataset, True),
# Test a split that splits datasets using torch Subset
(data, cvsplit, np.ndarray, False),
(data, cvsplit, Subset, True),
((MyTorchDataset(*data), None), cvsplit, Subset, False),
((MyTorchDataset(*data), None), cvsplit, Subset, True),
((MySkorchDataset(*data), None), cvsplit, np.ndarray, False),
((MySkorchDataset(*data), None), cvsplit, Subset, True),
]
for input_data, train_split, expected_type, caching in table:
self.net_input_is_scoring_input(
net_cls,
module_cls,
scoring_cls,
input_data,
train_split,
expected_type,
caching)
def __init__(self,
module,
*args,
criterion=torch.nn.BCEWithLogitsLoss,
train_split=CVSplit(5, stratified=True),
threshold=0.5,
**kwargs):
super().__init__(module,
criterion=criterion,
train_split=train_split,
*args,
**kwargs)
self.threshold = threshold
def test_fit_with_dataset_without_explicit_y(
self, net_cls, module_cls, dataset_cls, data):
from skorch.dataset import CVSplit
net = net_cls(
module_cls,
max_epochs=1,
train_split=CVSplit(stratified=False),
)
ds = dataset_cls(*data)
net.fit(ds, None) # does not raise
for key in ('train_loss', 'valid_loss', 'valid_acc'):
assert key in net.history[-1]
def test_fit_with_dataset_stratified_without_explicit_y_raises(
self, net_cls, module_cls, dataset_cls, data):
from skorch.dataset import CVSplit
net = net_cls(
module_cls,
train_split=CVSplit(stratified=True),
)
ds = dataset_cls(*data)
with pytest.raises(ValueError) as exc:
net.fit(ds, None)
msg = "Stratified CV requires explicitely passing a suitable y."
assert exc.value.args[0] == msg
def build_estimator(hyperparams, train_data, test=False):
device = "cuda" if torch.cuda.is_available() else "cpu"
# Extract info from training data
X, y, *_ = train_data
in_features = X.shape[1]
callbacks = [
("r2_score_valid", EpochScoring("r2", lower_is_better=False)),
(
"early_stopping",
EarlyStopping(monitor="valid_loss", patience=5, lower_is_better=True),
),
(
"learning_rate_scheduler",
LRScheduler(
policy=lr_scheduler.ReduceLROnPlateau,
monitor="valid_loss",
# Following kargs are passed to the
# lr scheduler constructor
mode="min",
min_lr=1e-5,
),
),
]
return NeuralNetRegressor(
NNModule,
criterion=nn.MSELoss,
optimizer=torch.optim.SGD,
max_epochs=300,
iterator_train__shuffle=True, # Shuffle training data on each epoch
callbacks=callbacks,
device=device,
train_split=CVSplit(cv=5, random_state=RANDOM_STATE),
lr=hyperparams["lr"],
batch_size=hyperparams["batch_size"],
module__in_features=in_features,
module__n_layers=hyperparams["n_layers"],
module__n_neuron_per_layer=hyperparams["n_neuron_per_layer"],
module__activation=getattr(F, hyperparams["activation"]),
module__p_dropout=hyperparams["p_dropout"],
optimizer__momentum=hyperparams["momentum"],
optimizer__weight_decay=hyperparams["weight_decay"],
optimizer__nesterov=True,
verbose=3,
iterator_train__num_workers=4,
iterator_valid__num_workers=4,
)
def _DDTClassifier(self):
if self.dataset == 'ttt':
depth = 13
enc = OneHotEncoder(categories='auto', sparse=False)
enc = enc.fit(self.x)
self.feat_lbl = enc.get_feature_names(self.feat_lbl).tolist()
self.x = enc.transform(self.x).astype(np.float32)
elif self.dataset == 'cancer':
depth = 8
elif self.dataset == 'cesarean':
depth = 11
enc = OneHotEncoder(
categories='auto',
sparse=False,
)
enc = enc.fit(self.x)
self.feat_lbl = enc.get_feature_names(self.feat_lbl).tolist()
self.x = enc.transform(self.x).astype(np.float32)
else:
raise ValueError('[ERROR] Invalid Dataset.')
n_output = len(self.target_lbl)
n_input = self.x.shape[1]
module = lambda: FDDTN(depth=depth,
n_input=n_input,
n_output=n_output,
continuous=False,
labels=self.feat_lbl,
param_initer=lambda *x: 0.5 * torch.ones(*x),
action_labels=self.target_lbl)
NeuralNetClassifier.train_step_single = train_step_single_monkey_patch
NeuralNetClassifier.validation_step = validation_step_monkey_patch
NeuralNetClassifier._default_callbacks = property(
callbacks_monkey_patch)
self.classifier = NeuralNetClassifier(
module=module,
criterion=nn.CrossEntropyLoss,
optimizer=Adam,
train_split=CVSplit(cv=0.3),
# callbacks=[('EarlyStopping', EarlyStopping(patience=20,
# threshold=1e-6,
# threshold_mode='abs'))],
lr=1e-2,
max_epochs=600,
batch_size=256,
device='cuda')
self.classifier.encoder = self.enc
self._reset_classifier()
return self.classifier
def __call__(self,
dataset: Union[Dataset, np.array],
y: Union[torch.Tensor, np.array, None] = None):
valid = getattr(dataset, 'valid', None)
if valid is not None:
return dataset, valid
if isinstance(self.split, CVSplit):
train, valid = self.split(dataset, y)
else:
split = CVSplit(self.split)
train, valid = split(dataset, y)
return train, valid
def run(self):
data = self.load('data')
sc = self.load('sc')
Y = data['author'].values
Y = Y.astype('float32')
X = data.drop(columns=['author']).values
X = sc.transform(X)
global INPUT_LEN
INPUT_LEN = len(X[0])
model = NeuralNetBinaryClassifier(NN,
max_epochs=100,
iterator_train__shuffle=True,
train_split=CVSplit(cv=10,
stratified=True,
random_state=0))
model.fit(X, Y)
self.dump(model)
def build_estimator(hyperparams, train_data, test=False):
device = 'cuda' if torch.cuda.is_available() else 'cpu'
# Extract info from training data
X, y, *_ = train_data
in_features = X.shape[1]
callbacks = [
('r2_score_valid', EpochScoring('r2',
lower_is_better=False)),
('early_stopping', EarlyStopping(monitor='valid_loss',
patience=5,
lower_is_better=True)),
('learning_rate_scheduler', LRScheduler(policy=lr_scheduler.ReduceLROnPlateau,
monitor='valid_loss',
# Following kargs are passed to the
# lr scheduler constructor
mode='min',
min_lr=1e-5
)),
]
return NeuralNetRegressor(
NNModule,
criterion=nn.MSELoss,
optimizer=torch.optim.SGD,
max_epochs=300,
iterator_train__shuffle=True, # Shuffle training data on each epoch
callbacks=callbacks,
device=device,
train_split=CVSplit(cv=5, random_state=RANDOM_STATE),
lr=hyperparams['lr'],
batch_size=hyperparams['batch_size'],
module__in_features=in_features,
module__n_layers=hyperparams['n_layers'],
module__n_neuron_per_layer=hyperparams['n_neuron_per_layer'],
module__activation=getattr(F, hyperparams['activation']),
module__p_dropout=hyperparams['p_dropout'],
optimizer__momentum=hyperparams['momentum'],
optimizer__weight_decay=hyperparams['weight_decay'],
optimizer__nesterov=True,
verbose=3,
iterator_train__num_workers=4,
iterator_valid__num_workers=4
)
def __init__(self,
module,
critic,
*args,
train_split=CVSplit(10),
train_generator_every=1,
critic_optimizer=torch.optim.SGD,
**kwargs):
self.critic = critic
self.critic_optimizer = critic_optimizer
self.train_generator_every = train_generator_every
super().__init__(module,
*args,
criterion=None,
train_split=train_split,
**kwargs)
def test_transformer_tsp_multisamples(device):
'''multivariate test'''
cuda_check(device)
start = time.time()
tsp = TimeSeriesPredictor(
Transformer(d_model=12),
lr=1e-5,
lambda1=1e-8,
optimizer__weight_decay=1e-8,
iterator_train__shuffle=True,
early_stopping=EarlyStopping(patience=100),
max_epochs=500,
train_split=CVSplit(10),
optimizer=Adam,
device=device,
)
past_pattern_length = 24
future_pattern_length = 12
pattern_length = past_pattern_length + future_pattern_length
# pylint: disable-next=line-too-long
fsd = FlightSeriesDataset(pattern_length,
future_pattern_length,
pattern_length,
stride=1,
generate_test_dataset=True)
tsp.fit(fsd)
end = time.time()
elapsed = timedelta(seconds=end - start)
print(f"Fitting in {device} time delta: {elapsed}")
mean_r2_score = tsp.score(tsp.dataset)
assert mean_r2_score > -0.5
netout = tsp.predict(fsd.test.x)
idx = np.random.randint(0, len(fsd.test.x))
y_true = fsd.test.y[idx, :, :]
y_hat = netout[idx, :, :]
r2s = r2_score(y_true, y_hat)
assert r2s > -1
print(f"Final R2 score: {r2s}")
def __init__(self,
module,
critic,
*args,
criterion=nn.BCELoss,
train_split=CVSplit(10),
train_generator_every=1,
critic_optimizer=torch.optim.SGD,
**kwargs):
super().__init__(module,
*args,
critic=critic,
critic_optimizer=critic_optimizer,
train_split=train_split,
train_generator_every=train_generator_every,
**kwargs)
self.criterion = criterion
def final_fit(self, dataset, best_params=None, train_all=False):
if best_params is None:
best_params = self.model.get_params()
# Once the best parameters are found, the best model is trained on the whole training set.
if not self.model.train_split is None and isinstance(self.model.train_split, CVSplit):
best_params.update({"train_split": None if train_all else CVSplit(5)})
# Callbacks
train_acc = BatchScoring(scoring='accuracy', on_train=True,
name='train_acc', lower_is_better=False)
# Callbacks
valid_acc = BatchScoring(scoring='accuracy', on_train=False,
name='valid_acc', lower_is_better=False)
best_params.update({"callbacks": [train_acc, valid_acc]})
self.best_model.set_params(**best_params)
self.best_model.fit(dataset, None)
# saving
with open(path.join(ARTIFACTS_DIR, self.name + '.pkl'), 'wb') as f:
pickle.dump(self, f)
def __init__(self,
module,
*args,
valid_transform=None,
criterion=torch.nn.CrossEntropyLoss,
train_split=CVSplit(5, stratified=False),
classes=None,
**kwargs):
super().__init__(module,
*args,
criterion=criterion,
train_split=train_split,
classes=classes,
**kwargs)
if valid_transform is None:
self.valid_transform = Compose(
[ToTensor(),
Normalize((MEAN_PIXEL, ), (STD_PIXEL, ))])
else:
self.valid_transform = valid_transform
def __init__(self,
module: nn.Module,
model_name: str,
sub_folder: str,
hyperparamters: dict,
optimizer,
gesture_list: list,
callbacks: list,
train_split=CVSplit(cv=0.1, random_state=0)):
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
super(SiameseEMG, self).__init__(
module,
criterion=nn.TripletMarginLoss,
optimizer=optimizer,
lr=hyperparamters['lr'],
max_epochs=hyperparamters['epoch'],
train_split=train_split,
callbacks=callbacks,
device=device,
iterator_train__shuffle=True,
iterator_train__num_workers=4,
iterator_train__batch_size=hyperparamters['train_batch_size'],
iterator_valid__shuffle=False,
iterator_valid__num_workers=4,
iterator_valid__batch_size=hyperparamters['valid_batch_size'])
self.model_name = model_name
self.hyperparamters = hyperparamters
self.distance = PairwiseDistance().to(self.device)
self.model_path = generate_folder('checkpoints',
model_name,
sub_folder=sub_folder)
self.clf = KNeighborsClassifier(n_neighbors=5)
self.clf_fit = False
self.anchors = []
self.labels = []
print('build a new model, init parameters of {}'.format(model_name))
param_dict = self.load_pretrained("pretrained_end_params.pt")
self.module.load_state_dict(param_dict)
def prepare_learnt_model(model_args, path_tfms, is_meta, verbose=2):
"""Model builder if learnt transforms are involved.
The key difference (as explained in prepare_non_learnt_model) between this function and prepare_non_learnt_model
is that the
Args:
model_args (dict): Experiment model args as defined in the main experiment function.
path_tfms (Pipeline): An sklearn pipeline of path transformations to be applied before model training.
is_meta (bool): Set True for a dyadic meta model.
verbose (int): Output verbosity level.
Returns:
"""
# Initialise the signature string class.
model_args['is_meta'] = is_meta
module = SignatureStringModel(**model_args)
model = NeuralNetClassifier(
module=module,
criterion=nn.BCEWithLogitsLoss if model_args['out_channels'] == 1 else nn.CrossEntropyLoss,
batch_size=64,
verbose=verbose,
iterator_train__drop_last=True,
callbacks=[
('scheduler', LRScheduler(policy='ReduceLROnPlateau')),
('val_stopping', EarlyStopping(monitor='valid_loss', patience=30)),
('checkpoint', CustomCheckpoint(monitor='valid_loss_best')),
('scorer', EpochScoring(custom_scorer, lower_is_better=False, name='true_acc'))
],
train_split=CVSplit(cv=5, random_state=1, stratified=True),
device=device if model_args['gpu'] else 'cpu',
)
pipeline = Pipeline([
*path_tfms,
('classifier', model)
])
return pipeline
def test_main(stride, test_main_context):
context = test_main_context(stride)
past_pattern_length = context['past_pattern_length']
future_pattern_length = context['future_pattern_length']
pattern_length = past_pattern_length + future_pattern_length
tsp = TimeSeriesPredictor(
BenchmarkLSTM(
initial_forget_gate_bias=1,
hidden_dim=7,
num_layers=1,
),
lr=context['lr'],
lambda1=1e-8,
optimizer__weight_decay=1e-8,
iterator_train__shuffle=True,
early_stopping=EarlyStopping(patience=100),
max_epochs=500,
train_split=CVSplit(context['n_cv_splits']),
optimizer=Adam,
)
fsd = FlightSeriesDataset(pattern_length,
future_pattern_length,
context['except_last_n'],
stride=stride,
generate_test_dataset=True)
tsp.fit(fsd)
mean_r2_score = tsp.score(tsp.dataset)
assert mean_r2_score > context['mean_r2_score']
netout = tsp.predict(fsd.test.x)
idx = np.random.randint(0, len(fsd.test.x))
y_true = fsd.test.y[idx, :, :]
y_hat = netout[idx, :, :]
r2s = r2_score(y_true, y_hat)
print("Final R2 score: {}".format(r2s))
assert r2s > context['final_r2_score']
def configureAnchor(outpath, checkpoint: Path = None):
batch_size = 4096
lr = 1e-4
model_args = {
"module__pool": "last",
"module__input_size": 19,
"module__rnn_size": 128,
"module__rnn_layers": 3,
"module__latent_size": 128
}
dist_plot = Callbacks.DistPlot(outpath)
loss_plot = Callbacks.EpochPlot(outpath, ["train_loss", "valid_loss"])
net = ad.WindowedAnomalyDetector(tripletloss.GruLinear,
tripletloss.ContextualCoherency,
optimizer=torch.optim.Adam,
iterator_train__shuffle=False,
lr=lr,
batch_size=batch_size,
max_epochs=MAX_EPOCHS,
**model_args,
device=DEVICE,
verbose=1,
train_split=CVSplit(5, random_state=SEED),
callbacks=[
dist_plot, loss_plot,
EarlyStopping("valid_loss",
lower_is_better=True,
patience=PATIENCE)
])
if checkpoint is not None:
net.initialize_context(int(TL_CONTEXT_LEN / 2))
net.initialize()
state_dict = torch.load(str(checkpoint),
map_location=torch.device("cpu"))
net.module_.load_state_dict(state_dict)
return net
def configureSeq2Seq(outpath, checkpoint: Path = None):
batch_size = 64
lr = 1e-4
model_args = {
"module__pool": "mean",
"module__input_size": 19,
"module__teacher_forcing_ratio": 7.,
"module__rnn_layers": 1,
"module__latent_size": 128
}
loss_plot = Callbacks.EpochPlot(outpath, ["train_loss", "valid_loss"])
net = ad.WindowedAnomalyDetector(autoencoder.Seq2Seq,
autoencoder.ReconstructionError,
optimizer=torch.optim.Adam,
iterator_train__shuffle=False,
lr=lr,
batch_size=batch_size,
max_epochs=MAX_EPOCHS,
**model_args,
device=DEVICE,
verbose=1,
train_split=CVSplit(5, random_state=SEED),
callbacks=[
loss_plot,
EarlyStopping("valid_loss",
lower_is_better=True,
patience=PATIENCE)
])
if checkpoint is not None:
net.initialize_context(SEQ2SEQ_CONTEXT_LEN)
net.initialize()
state_dict = torch.load(str(checkpoint),
map_location=torch.device("cpu"))
net.module_.load_state_dict(state_dict)
return net
def __init__(self,
module,
alpha=1,
regularizer='none',
criterion=torch.nn.NLLLoss,
train_split=CVSplit(5, stratified=True),
classes=None,
*args,
**kwargs):
self.alpha = alpha
self.regularizer = regularizer
if 'regularizer' in kwargs.keys():
kwargs.pop('regularizer')
if 'alpha' in kwargs.keys():
kwargs.pop('alpha')
super().__init__(module,
*args,
criterion=criterion,
train_split=train_split,
classes=classes,
**kwargs)
def __init__(
self,
module: nn.Module,
model_name: str,
sub_folder: str,
hyperparamters: dict,
optimizer,
gesture_list: list, # all gestures index
callbacks: list,
# train_new_model=True,
train_split=CVSplit(cv=0.1, random_state=0)):
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
super(EMGClassifier, self).__init__(
module,
criterion=nn.CrossEntropyLoss,
optimizer=optimizer,
lr=hyperparamters['lr'],
max_epochs=hyperparamters['epoch'],
train_split=train_split,
callbacks=callbacks,
device=device,
iterator_train__shuffle=True,
iterator_train__num_workers=4,
iterator_train__batch_size=hyperparamters['train_batch_size'],
iterator_valid__shuffle=False,
iterator_valid__num_workers=4,
iterator_valid__batch_size=hyperparamters['valid_batch_size'])
self.model_name = model_name
self.hyperparamters = hyperparamters
# self.extend_scale = dataset.scale
self._gesture_mapping = None
self._all_gestures = gesture_list
self.module.apply(init_parameters)
self.model_trained = False
self.model_path = generate_folder('checkpoints',
model_name,
sub_folder=sub_folder)
