def __init__(self, config):
self.config = config
keras_backend = self.get_config('settings',
'keras_backend',
default='')
if keras_backend:
os.environ['KERAS_BACKEND'] = keras_backend
self.input = instance_from_config(self.get_config('input'))
self.algorithm = instance_from_config(self.get_config('algorithm'))
self.output = instance_from_config(self.get_config('output'))
self.steps = []
self.steps.append(self.input)
for preprocessing_step in self.get_config('preprocessing', default=[]):
self.steps.append(instance_from_config(preprocessing_step))
self.steps.append(self.algorithm)
for postprocessing_step in self.get_config('postprocessing',
default=[]):
self.steps.append(instance_from_config(postprocessing_step))
self.steps.append(self.output)
def __init__(self, config):
super().__init__(config)
self.do_fit_condition = instance_from_config(
self.get_config(
'do_fit_condition',
default={'class': 'ml4iiot.conditions.TrueCondition'}))
self.do_predict_condition = instance_from_config(
self.get_config(
'do_predict_condition',
default={'class': 'ml4iiot.conditions.TrueCondition'}))
pd.options.mode.chained_assignment = None
def __init__(self, config):
super().__init__(config)
self.output_adapters = []
for output_config in self.get_config('output_adapters'):
self.output_adapters.append(instance_from_config(output_config))
def __init__(self, config):
super().__init__(config)
self.do_skip_condition = instance_from_config(
self.get_config(
'do_skip',
default={'class': 'ml4iiot.conditions.FalseCondition'}))
def __init__(self, config):
super().__init__(config)
self.index_column = self.get_config('index_column')
windowing_strategy = self.get_config('windowing_strategy')
windowing_strategy['config']['input'] = self
self.windowing_strategy = instance_from_config(self.get_config('windowing_strategy'))
def test_inverted_condition(self):
condition_true = instance_from_config({
'class': 'ml4iiot.conditions.FalseCondition',
'config': {
'inverted': True
}
})
condition_false = instance_from_config({
'class': 'ml4iiot.conditions.FalseCondition',
'config': {
'inverted': False
}
})
self.assertTrue(condition_true.evaluate(None))
self.assertFalse(condition_false.evaluate(None))
def __init__(self, config):
super().__init__(config)
self.conditions = []
self.operator = self.get_config('operator', default='and')
for condition_config in self.get_config('conditions', default=[]):
self.conditions.append(instance_from_config(condition_config))
def __init__(self, config):
super().__init__(config)
self.producer = None
self.topics_mapping = self.get_config('kafka_topics_mapping')
self.output_mapper = instance_from_config(
self.get_config(
'kafka_output_mapper',
default={'class': 'ml4iiot.output.kafka.JsonOutputMapper'}))
def __init__(self, config):
super().__init__(config)
self.do_output_condition = instance_from_config(
self.get_config(
'do_output_condition',
default={'class': 'ml4iiot.conditions.TrueCondition'}))
self.output_file_name = self.get_config('output_file_name',
default='csv_output.csv')
self.output_file_path = get_current_out_path(self.output_file_name)
self.date_format = self.get_config('date_format', default='%s.%f')
self.columns = self.get_config('columns', default=None)
self.output_file = None
self.write_header = True
def test_time_delta_condition(self):
time_delta_condition = instance_from_config({
'class': 'ml4iiot.conditions.TimeDeltaCondition',
'config': {
'min_time_delta': {
'seconds': 10,
},
'max_time_delta': {
'seconds': 100
}
}
})
valid = self.create_data_frame([0, 10, 20, 40, 100])
too_short = self.create_data_frame([0, 5, 15, 20, 25])
too_large = self.create_data_frame([0, 50, 150, 300, 350])
self.assertTrue(time_delta_condition.evaluate(valid))
self.assertFalse(time_delta_condition.evaluate(too_short))
self.assertFalse(time_delta_condition.evaluate(too_large))
def test_daytime_condition(self):
daytime_condition = instance_from_config({
'class': 'ml4iiot.conditions.DaytimeCondition',
'config': {
'start_time': '08:00:00',
'end_time': '20:00:00'
}
})
before_time_window = self.create_data_frame(self.seconds_in_an_hour *
7)
in_time_window_1 = self.create_data_frame(self.seconds_in_an_hour * 9)
in_time_window_2 = self.create_data_frame(self.seconds_in_an_hour * 14)
after_time_window = self.create_data_frame(self.seconds_in_an_hour *
22)
self.assertFalse(daytime_condition.evaluate(before_time_window))
self.assertTrue(daytime_condition.evaluate(in_time_window_1))
self.assertTrue(daytime_condition.evaluate(in_time_window_2))
self.assertFalse(daytime_condition.evaluate(after_time_window))
def test_weekday_condition(self):
weekday_condition = instance_from_config({
'class': 'ml4iiot.conditions.WeekdayCondition',
'config': {
'weekdays': ['Monday', 'Tuesday']
}
})
thursday = self.create_data_frame(self.seconds_in_a_day * 0)
friday = self.create_data_frame(self.seconds_in_a_day * 1)
saturday = self.create_data_frame(self.seconds_in_a_day * 2)
sunday = self.create_data_frame(self.seconds_in_a_day * 3)
monday = self.create_data_frame(self.seconds_in_a_day * 4)
tuesday = self.create_data_frame(self.seconds_in_a_day * 5)
wednesday = self.create_data_frame(self.seconds_in_a_day * 6)
self.assertFalse(weekday_condition.evaluate(thursday))
self.assertFalse(weekday_condition.evaluate(friday))
self.assertFalse(weekday_condition.evaluate(saturday))
self.assertFalse(weekday_condition.evaluate(sunday))
self.assertFalse(weekday_condition.evaluate(wednesday))
self.assertTrue(weekday_condition.evaluate(monday))
self.assertTrue(weekday_condition.evaluate(tuesday))
def test_composite_condition(self):
condition_and_true = instance_from_config({
'class': 'ml4iiot.conditions.CompositeCondition',
'config': {
'operator':
'and',
'conditions': [
{
'class': 'ml4iiot.conditions.TrueCondition'
},
{
'class': 'ml4iiot.conditions.TrueCondition'
},
]
}
})
condition_and_false_1 = instance_from_config({
'class': 'ml4iiot.conditions.CompositeCondition',
'config': {
'operator':
'and',
'conditions': [
{
'class': 'ml4iiot.conditions.TrueCondition'
},
{
'class': 'ml4iiot.conditions.FalseCondition'
},
]
}
})
condition_and_false_2 = instance_from_config({
'class': 'ml4iiot.conditions.CompositeCondition',
'config': {
'operator':
'and',
'conditions': [
{
'class': 'ml4iiot.conditions.FalseCondition'
},
{
'class': 'ml4iiot.conditions.TrueCondition'
},
]
}
})
condition_and_false_3 = instance_from_config({
'class': 'ml4iiot.conditions.CompositeCondition',
'config': {
'operator':
'and',
'conditions': [
{
'class': 'ml4iiot.conditions.FalseCondition'
},
{
'class': 'ml4iiot.conditions.FalseCondition'
},
]
}
})
condition_or_false = instance_from_config({
'class': 'ml4iiot.conditions.CompositeCondition',
'config': {
'operator':
'or',
'conditions': [
{
'class': 'ml4iiot.conditions.FalseCondition'
},
{
'class': 'ml4iiot.conditions.FalseCondition'
},
]
}
})
condition_or_true_1 = instance_from_config({
'class': 'ml4iiot.conditions.CompositeCondition',
'config': {
'operator':
'or',
'conditions': [
{
'class': 'ml4iiot.conditions.TrueCondition'
},
{
'class': 'ml4iiot.conditions.FalseCondition'
},
]
}
})
condition_or_true_2 = instance_from_config({
'class': 'ml4iiot.conditions.CompositeCondition',
'config': {
'operator':
'or',
'conditions': [
{
'class': 'ml4iiot.conditions.FalseCondition'
},
{
'class': 'ml4iiot.conditions.TrueCondition'
},
]
}
})
condition_or_true_3 = instance_from_config({
'class': 'ml4iiot.conditions.CompositeCondition',
'config': {
'operator':
'or',
'conditions': [
{
'class': 'ml4iiot.conditions.TrueCondition'
},
{
'class': 'ml4iiot.conditions.TrueCondition'
},
]
}
})
self.assertTrue(condition_and_true.evaluate(None))
self.assertFalse(condition_and_false_1.evaluate(None))
self.assertFalse(condition_and_false_2.evaluate(None))
self.assertFalse(condition_and_false_3.evaluate(None))
self.assertFalse(condition_or_false.evaluate(None))
self.assertTrue(condition_or_true_1.evaluate(None))
self.assertTrue(condition_or_true_2.evaluate(None))
self.assertTrue(condition_or_true_3.evaluate(None))
def test_false_condition(self):
condition = instance_from_config(
{'class': 'ml4iiot.conditions.FalseCondition'})
self.assertFalse(condition.evaluate(None))
def test_true_condition(self):
condition = instance_from_config(
{'class': 'ml4iiot.conditions.TrueCondition'})
self.assertTrue(condition.evaluate(None))
