def get_generator(self) -> Generator:
event_function: Callable[[History], float] = lambda history: \
2 * history.get_event(delay=2, null_value=0)
return Generator() \
.add_uniform(1, 3, round=0) \
.add_function(event_function, round=0)
def with_noise(self) -> Generator:
event_function: Callable[[History], float] = lambda history: \
np.sin(history.get_timestamp() / 60 / 60 * np.pi / 2)
return Generator() \
.set_time('2010-10-20 20:00', step='1h', precision='10m') \
.add_function(event_function, round=1)
def get_generator(self) -> Generator:
return Generator() \
.add_function(self.__functions[0], data_type=int, label='1') \
.add_function(self.__functions[1], data_type=int, label='2') \
.add_function(self.__functions[2], data_type=int, label='3') \
.add_function(self.__functions[3], data_type=int, label='4') \
.add_discrete(10, data_type=int)
def get_generator(self) -> Generator:
event_function: Callable[[History], float] = lambda history: \
np.sin(history.get_timestamp() / 60 / 5 * np.pi / 2)
return Generator() \
.set_time('2010-01-02 20:10', step='5m') \
.add_function(event_function, round=0)
def get_generator(self) -> Generator:
return Generator() \
.add_discrete(10, label='Cause') \
.add_discrete(10) \
.add_discrete(10) \
.add_discrete(10) \
.add_function(self.__function, label='Effect', round=0)
def test_function_combinations(self):
def effect_function(history: History) -> float:
value = history.get_event()
if history.get_event(201, delay=200):
value *= 1.5
elif history.get_event(position=301, delay=300, null_value=None):
value *= 3
elif history.get_event(delay=500):
value *= 3
elif history.get_event(delay=600, position=601):
value *= 3
value = history.get_event(401) + 4
return value
relations = Generator() \
.add_function(effect_function) \
.build_relations()
expected = [
Relation(History.DEFAULT_POSITION, History.DEFAULT_POSITION,
History.DEFAULT_DELAY),
Relation(201, History.DEFAULT_POSITION, 200),
Relation(301, History.DEFAULT_POSITION, 300),
Relation(History.DEFAULT_POSITION, History.DEFAULT_POSITION, 500),
Relation(601, History.DEFAULT_POSITION, 600),
Relation(401, History.DEFAULT_POSITION, History.DEFAULT_DELAY),
]
RelationAssert.equal(self, expected, relations)
def test_time_arguments(self):
def func1(history: History) -> float:
return history.get_datetime().weekday()
def func2(history: History) -> float:
return history.get_datetime(1).isocalendar()[1]
def func3(history: History) -> float:
return history.get_timestamp(delay=2)
relations = Generator() \
.set_time('2020-02-20', step='1d') \
.add_function(func1, shadow=True) \
.add_function(func2, shadow=True) \
.add_function(func3, shadow=True) \
.add_function(lambda h: h.get_event(1) * h.get_event(2, delay=2) * h.get_event(3)) \
.build_relations()
expected = [
Relation(0, 1, 0),
Relation(0, 2, 1),
Relation(0, 3, 2),
Relation(1, 4, 0),
Relation(2, 4, 2),
Relation(3, 4, 0),
]
RelationAssert.equal(self, expected, relations)
def year_progressive(self) -> Generator:
return Generator() \
.set_time('2020-02-20', step='1d') \
.add_uniform(250, 300, shadow=True) \
.add_function(self.week_day, shadow=True) \
.add_function(self.year_week, shadow=True) \
.add_function(lambda h: h.get_event(1) * h.get_event(2) * h.get_event(3))
def basic(self) -> Generator:
event_function: Callable[[History], float] = lambda history: \
1 if history.get_event() == 1 else None
return Generator(sequential=True) \
.add_discrete() \
.add_function(event_function) \
.add_discrete()
def simple(self) -> Generator:
return Generator() \
.add_uniform(0, 1, round=1) \
.add_uniform(0, 1, round=1) \
.add_uniform(0, 1, round=1) \
.add_uniform(0, 1, round=1) \
.add_uniform(0, 1, round=1) \
.add_function(lambda h: h.e(1) > 0.3 and h.e(2) > 0.8 or h.e(3) < 0.3, label='P', round=3)
def test_single_label(self):
dataset = Generator() \
.add_uniform() \
.add_uniform() \
.generate()
self.assertEqual(EventInterface.LABEL_EVENT + '1', dataset.columns[0])
self.assertEqual(EventInterface.LABEL_EVENT + '2', dataset.columns[1])
def get_generator(self) -> Generator:
event_function: Callable[[History], float] = lambda history: \
1 if history.get_event(1) == 1 else 0
return Generator() \
.add_discrete() \
.add_discrete() \
.add_function(event_function, round=0)
def get_generator(self) -> Generator:
event_function: Callable[[History], float] = lambda history: \
history.get_event(1) + history.get_event(2)
return Generator() \
.add_uniform(shadow=True) \
.add_uniform() \
.add_function(event_function)
def get_generator(self) -> Generator:
event_function: Callable[[History], float] = lambda history: \
2 * history.get_event(delay=1) + 3
return Generator(sequential=True) \
.add_uniform(round=0) \
.add_uniform(round=0) \
.add_function(event_function, round=0)
def complex(self) -> Generator:
return Generator(sequential=True) \
.set_time(step='10s', precision='10s') \
.add_function(
lambda h: Uniform(70, 100, round=0).generate() if len(h.get_range(3, time_range='3m')) == 0 else None,
probability=0.4, label='System\nhigh load'
) \
.add_categorical(('notice', 'warning', 'critical'), probability=0.2, label='System\nfault') \
.add_function(self.server_down, probability=0.9, label='Server\ndown')
def test_some(self):
random.seed(1)
event_function: Callable[[History], float] = lambda history: \
1 if history.get_event() == 1 else 0
dataset = Generator() \
.add_discrete() \
.add_discrete() \
.add_function(event_function)
def get_generator(self) -> Generator:
return Generator() \
.add_discrete(100, label='Cause') \
.add_function(self.__functions[0], label='Effect 1') \
.add_function(self.__functions[1], label='Effect 2') \
.add_function(self.__functions[2], label='Effect 3') \
.add_discrete(10) \
.add_discrete(10) \
.add_discrete(10) \
.add_discrete(10)
def test_get_all_events(self):
generator = Generator() \
.add_uniform() \
.add_uniform()
events = generator.get_events()
expected_events = ['T', 'E1', 'E2']
for key, event in enumerate(events):
self.assertEqual(event.label, expected_events[key])
def complex(self) -> Generator:
return Generator() \
.add_uniform(0, 1, round=3) \
.add_uniform(0, 1, round=3, shadow=True) \
.add_uniform(0, 1, round=3) \
.add_uniform(0, 1, round=3) \
.add_function(lambda h: (h.e(3) + h.e(4)) / 2, round=3) \
.add_uniform(0, 1, round=3) \
.add_uniform(0, 1, round=3) \
.add_function(self.pathology, label='P', round=3)
def test_lambda_as_argument(self):
relations = Generator() \
.add_uniform() \
.add_uniform(6, 10).add_function(lambda h: h.get_event(2, delay=3)) \
.build_relations()
expected = [
Relation(2, 3, 3),
]
RelationAssert.equal(self, expected, relations)
def test_get_events_exclude_shadow(self):
generator = Generator() \
.add_uniform() \
.add_uniform(shadow=True) \
.add_uniform()
events = generator.get_events(include_shadow=False)
expected_events = ['E1', 'E3']
for key, event in enumerate(events):
self.assertEqual(event.label, expected_events[key])
def predict(arr, model):
x_in = [arr]
X_in = np.array(x_in)
X_in = binarize_along_last_axis(X_in, n_classes=10)
pred = model.predict(X_in)
pred = pred.argmax(axis=-1)
pred_gen = Generator(pred[0, ...].ravel().tolist())
return pred_gen
def test_multiple_cause_labels(self):
dataset = Generator() \
.add_uniform() \
.add_uniform() \
.add_uniform() \
.add_uniform() \
.generate()
self.assertEqual(EventInterface.LABEL_EVENT + '1', dataset.columns[0])
self.assertEqual(EventInterface.LABEL_EVENT + '2', dataset.columns[1])
self.assertEqual(EventInterface.LABEL_EVENT + '3', dataset.columns[2])
self.assertEqual(EventInterface.LABEL_EVENT + '4', dataset.columns[3])
def test_search():
for seed in range(50):
random.seed(seed)
event_function: Callable[[History], float] = lambda history: \
history.get_event(1) and history.get_event(2)
dataset = Generator() \
.add_discrete() \
.add_discrete() \
.add_function(event_function).generate()
d = 3
def test_independent_effects(self):
relations = Generator() \
.add_uniform() \
.add_function(lambda h: h.get_event()) \
.add_linear() \
.add_function(lambda h: h.get_event(3)) \
.build_relations()
expected = [
Relation(1, 2, 0),
Relation(3, 4, 0),
]
RelationAssert.equal(self, expected, relations)
def test_simple_relation_function(self):
def effect_function(history: History) -> float:
return history.get_event()
relations = Generator() \
.add_function(effect_function) \
.build_relations()
expected = [
Relation(History.DEFAULT_POSITION, History.DEFAULT_POSITION,
History.DEFAULT_DELAY)
]
RelationAssert.equal(self, expected, relations)
def test_time_alias():
effect_function: Callable[[History], float] = lambda history: \
np.sin(history.t() / 60 / 5 * np.pi / 2)
dataset = Generator() \
.set_time('2018-05-13 20:15', step='5m') \
.add_function(effect_function) \
.generate(5)
expected = pd.DataFrame({
EventInterface.LABEL_EVENT + '1': [-1, 0, 1, 0, -1],
EventInterface.LABEL_TIME:
[1526235300, 1526235600, 1526235900, 1526236200, 1526236500],
})
pd.testing.assert_frame_equal(expected, dataset, check_dtype=False)
def test_multiple_effects():
random.seed(2)
dataset = Generator() \
.add_uniform() \
.add_function(lambda history: round(history.get_event()) * 2) \
.add_function(lambda history: history.get_event(2) + 1) \
.generate().round(0)
expected = pd.DataFrame({
EventInterface.LABEL_EVENT + '1': [1, 3, 4],
EventInterface.LABEL_EVENT + '2': [2, 6, 8],
EventInterface.LABEL_EVENT + '3': [3, 7, 9],
})
pd.testing.assert_frame_equal(expected, dataset, check_dtype=False)
def test_range_from_next_event():
random.seed(25)
dataset = Generator() \
.set_time('2018-05-13 20:15', step='5m') \
.add_categorical(('First', 'Second', 'Third')) \
.add_function(lambda history: 'Third' in history.get_range(time_range='10m')) \
.generate()
expected = pd.DataFrame({
EventInterface.LABEL_EVENT + '1': ['Third', 'First', 'Second'],
EventInterface.LABEL_EVENT + '2': [1, 1, 0],
EventInterface.LABEL_TIME: [1526235300, 1526235600, 1526235900],
})
pd.testing.assert_frame_equal(expected, dataset, check_dtype=False)
def get_sample(random_replace=True):
gen = Generator(base_numbers, shuffle_base=True)
gen.randomize(np.random.randint(20, 1000))
initial = gen.board.copy()
x_out = [[a.value for a in x] for x in initial.rows.values()]
gen.reduce_via_logical(np.random.randint(31, 360))
removed = gen.board.copy()
x_in = [[a.value for a in x] for x in removed.rows.values()]
if random_replace:
x_in = replace_with_zeros(x_in, ratio=np.random.uniform(0.6, 0.9))
return x_in, x_out
