def __init__(self):
super(OneHotVsMappingConverter, self).__init__()
## Verifier data ##
# 1 for a binarised level (only two options)
base_len = 1
self._len_key = "len"
self._vector_constraints = {}
# 1 value (generated)
for gen_key in ids_data.get_generators():
self._vector_constraints[gen_key] = {self._len_key: base_len + 1}
# 3 values for a split colour, 2 values for the position
for colr_key in ids_data.get_colours():
self._vector_constraints[colr_key] = {self._len_key: base_len + 5}
# Poses all have GPS
for pose_key in ids_data.get_poses():
self._vector_constraints[pose_key] = {self._len_key: base_len + 2}
# CC: One mapping
self._vector_constraints[ids_data.POSE_CC][self._len_key] += 1
# POI: Two mappings
self._vector_constraints[ids_data.POSE_POI][self._len_key] += 2
# TSP: x, y, targ_x, targ_y
self._vector_constraints[ids_data.POSE_TSP][self._len_key] += 4
def get_expected_classes(self, app_id):
""" Return a list of expected classes for the given app_id classifier. """
labels = None
verify_hash = None
if app_id in ids_data.get_generators():
labels = ids_data.get_labels_gens()
verify_hash = "3e7c91c61534c25b3eb15d40d0c99a73"
elif app_id in ids_data.get_colours():
labels = ids_data.get_labels_colrs()
verify_hash = "e5dce1652563eb67347003bc2f7f3e70"
elif app_id == ids_data.POSE_CC:
labels = ids_data.get_labels_pose_cc()
verify_hash = "5e550fa679c1e0845320660a3c98bb6f"
elif app_id == ids_data.POSE_POI:
labels = ids_data.get_labels_pose_poi()
verify_hash = "9d60b17b201114a17179334aeea66ab5"
elif app_id == ids_data.POSE_TSP:
labels = ids_data.get_labels_pose_tsp()
verify_hash = "9027b46c491b3c759215fdba37a93d84"
else:
raise ValueError("Invalid app_id given: {}".format(app_id))
ids_tools.verify_md5(labels, verify_hash)
return [self.label_int_mapping[x] for x in labels]
def encode_log_messages(self, app_id, log_messages):
"""
Either just convert the data or do convert to mapping
returns: Two-dimensional numpy.ndarray
"""
# "{f}" -> float(x)
if app_id in ids_data.get_generators():
return numpy.array([[float(log_message)]
for log_message in log_messages])
# "{i},{i},{i}" -> int(x), int(y), int(z)
if app_id in ids_data.get_colours():
colours = [[int(val) for val in msg.split(",")]
for msg in log_messages]
return numpy.array(colours)
# "DE" -> 3
if app_id == ids_data.POSE_CC:
country_code_mapping = ids_tools.enumerate_to_dict(
ids_data.get_country_codes(),
verify_hash="8ef55ff8ba5ce289a3d2a689edbaa423")
mapped = [[country_code_mapping[c]] for c in log_messages]
return numpy.array(mapped)
# "type,result" -> 1,7
if app_id == ids_data.POSE_POI:
poi_type_mapping = ids_tools.enumerate_to_dict(
ids_data.get_poi_types(),
verify_hash="f2fba0ed17e382e274f53bbcb142565b")
poi_result_mapping = ids_tools.enumerate_to_dict(
ids_data.get_poi_results(),
verify_hash="dd1c18c7188a48a686619fef8007fc64")
poi_pairs = [msg.split(",") for msg in log_messages]
poi_result = [[poi_type_mapping[a], poi_result_mapping[b]]
for (a, b) in poi_pairs]
return numpy.array(poi_result)
# "{x},{y},{x},{y}" -> int(x),int(y),int(x),int(y)
if app_id == ids_data.POSE_TSP:
coords_rows = [[int(coord) for coord in msg.split(",")]
for msg in log_messages]
assert (len(coords_rows[0]) == 4)
for coord in coords_rows[0]:
assert (coord >= 0 and coord < 500)
return numpy.array(coords_rows)
raise NotImplementedError("App ID {} not implemented".format(app_id))
def encode_log_messages(self, app_id, log_messages):
"""
Either just convert the data (data generators) or do a one-hot encoding of the log message.
returns: Two-dimensional numpy.ndarray with either 1 float value, 4 int values
or up to 11 binary encoded values per row.
"""
# Generators send "{f}"
if app_id in ids_data.get_generators():
# Return a list with float values
return numpy.array([[float(log_message)]
for log_message in log_messages])
# Colour sends "{i},{i},{i}"
if app_id in ids_data.get_colours():
colours = [[int(val) for val in msg.split(",")]
for msg in log_messages]
# Returns a list with 3 scaled colour floats in [0,1]
return self.colours_scale(colours)
# Country code string like "DE" or "CH"
if app_id == ids_data.POSE_CC:
# Returns a list with 5 binary flags
return self.country_codes_one_hot(log_messages)
# POI pair "type,result"
if app_id == ids_data.POSE_POI:
poi_pairs = [msg.split(",") for msg in log_messages]
# Returns a list with 11 binary flags
return self.poi_pairs_one_hot(poi_pairs)
# Two positions as "{},{},{},{}" (start,end as x,y)
if app_id == ids_data.POSE_TSP:
coords_rows = [[float(coord) for coord in msg.split(",")]
for msg in log_messages]
assert (len(coords_rows[0]) == 4)
for coord in coords_rows[0]:
assert (coord >= 0 and coord < 500)
# Return list of 4 scaled coordinate floats in [-1,1]
return self.positions_scale(coords_rows)
raise NotImplementedError("App ID {} not implemented".format(app_id))
def generate_log_entries(number):
""" Generate <number> LogEntry objects. """
result = []
vins = [
chr(random.choice(range(65, 91))) + str(x)
for x in random.sample(range(100000, 900000), int(number))
]
colr_gen = lambda: random.randint(0, 255)
tsp_gen = lambda: random.randint(0, 499)
log_msg_gens = [
(ids_data.get_generators(), lambda: str(float(random.randint(-3, 2)))),
(ids_data.get_colours(),
lambda: "{},{},{}".format(colr_gen(), colr_gen(), colr_gen())),
(ids_data.POSE_CC, lambda: random.choice(["DE", "AT", "CH", "FR"])),
(ids_data.POSE_POI, (lambda: random.choice(ids_data.get_poi_types()) +
"," + random.choice(ids_data.get_poi_results()))),
(ids_data.POSE_TSP, lambda: "{},{},{},{}".format(
tsp_gen(), tsp_gen(), tsp_gen(), tsp_gen()))
]
for i in range(0, int(number)):
vin = vins[i]
app_id = random.choice(ids_data.get_app_ids())
level = random.choice(ids_data.get_levels())
gps_position = "{},{}".format(tsp_gen(), tsp_gen())
log_message = None
for keys, gen in log_msg_gens:
if app_id in keys:
log_message = gen()
if not log_message:
raise ValueError("You suck!")
intrusion = random.choice(ids_data.get_labels())
result.append(
LogEntry(vin=vin,
app_id=app_id,
level=level,
gps_position=gps_position,
log_message=log_message,
intrusion=intrusion))
return result
def __init__(self):
""" Ctor. """
self.app_ids = ids_data.get_app_ids()
ids_tools.verify_md5(self.app_ids, "3a88e92473acb1ad1b56e05a8074c7bd")
self.level_mapping = ids_tools.enumerate_to_dict(
ids_data.get_levels(),
verify_hash="49942f0268aa668e146e533b676f03d0")
self.poi_type_mapping = ids_tools.enumerate_to_dict(
ids_data.get_poi_types(),
verify_hash="f2fba0ed17e382e274f53bbcb142565b")
self.poi_result_mapping = ids_tools.enumerate_to_dict(
ids_data.get_poi_results(),
verify_hash="dd1c18c7188a48a686619fef8007fc64")
self.label_int_mapping = ids_tools.enumerate_to_dict(
ids_data.get_labels(),
verify_hash="88074a13baa6f97fa4801f3b0ec53065")
## Verifier data ##
# 1 for a binarised level (only two options)
base_len = 1
self._len_key = "len"
self._vector_constraints = {}
# 1 value (generated)
for gen_key in ids_data.get_generators():
self._vector_constraints[gen_key] = {self._len_key: base_len + 1}
# 3 values for a split colour, 2 values for the position
for colr_key in ids_data.get_colours():
self._vector_constraints[colr_key] = {self._len_key: base_len + 5}
# Poses all have GPS
for pose_key in ids_data.get_poses():
self._vector_constraints[pose_key] = {self._len_key: base_len + 2}
# CC: One of five
self._vector_constraints[ids_data.POSE_CC][self._len_key] += 5
# POI: One of 4 types, one of 7 results
self._vector_constraints[ids_data.POSE_POI][self._len_key] += 11
# TSP: x, y, targ_x, targ_y
self._vector_constraints[ids_data.POSE_TSP][self._len_key] += 4