def detect(self, dataset):
_, features, _ = self.model_fn(dataset, **self.config)
scores, predictions, attentions = detect_fn(self.model, features,
dataset, self.config)
return AnomalyDetectionResult(scores=scores,
predictions=predictions,
attentions=attentions)
def detect(self, dataset):
"""
Calculate the anomaly score for each event attribute in each trace.
Anomaly score here is the mean squared error.
:param traces: traces to predict
:return:
scores: anomaly scores for each attribute;
shape is (#traces, max_trace_length - 1, #attributes)
"""
# Get features
_, features, _ = self.model_fn(dataset, **self.config)
# Parameters
input_size = int(self.model.input.shape[1])
features_size = int(features.shape[1])
if input_size > features_size:
features = np.pad(features,
[(0, 0), (0, input_size - features_size),
(0, 0)],
mode='constant')
elif input_size < features_size:
features = features[:, :input_size]
# Init anomaly scores array
scores = np.zeros(dataset.binary_targets.shape)
# Get predictions
predictions = self.model.predict(features)
# Calculate error
errors = np.power(features - predictions, 2)
# Split the errors according to the attribute dims
split = np.cumsum(np.tile(dataset.attribute_dims, [dataset.max_len]),
dtype=int)[:-1]
errors = np.split(errors, split, axis=1)
errors = np.array(
[np.mean(a, axis=1) if len(a) > 0 else 0.0 for a in errors])
for i in range(len(dataset.attribute_dims)):
error = errors[i::len(dataset.attribute_dims)]
scores[:, :, i] = error.T
return AnomalyDetectionResult(scores=scores)
def detect(self, dataset):
features = dataset.flat_features_2d
input_size = self._model.support_vectors_.shape[1]
features_size = features.shape[1]
if input_size > features_size:
features = np.pad(features,
[(0, 0), (0, input_size - features_size),
(0, 0)][:len(features.shape)],
mode='constant')
elif input_size < features_size:
features = features[:, :input_size]
anomaly_scores = np.zeros(dataset.binary_targets.shape, dtype=int)
pred = self._model.predict(features)
pred = (pred == -1)[:, np.newaxis, np.newaxis]
anomaly_scores += pred
return AnomalyDetectionResult(scores=anomaly_scores)
def detect(self, dataset):
scores = np.ones(dataset.binary_targets.shape)
scores *= np.random.randint(
0, 2, dataset.binary_targets.shape[0])[:, np.newaxis, np.newaxis]
return AnomalyDetectionResult(scores=scores)
def detect(self, dataset):
return AnomalyDetectionResult(scores=dataset.binary_targets)