def perform_localisation_benchmark(
model_params: ModelParameters, index_config: IndexConfig,
benchmark_params: BenchmarkParameters) -> BenchmarkResult:
model = LocalisationModel(model_params.localisation_type, index_config,
model_params.sigma, model_params.m,
model_params.k, model_params.num_workers)
log.info(f"Localisation model: {repr(model)}")
if index_config.index_dir is None:
log.info("Getting training data")
ids, coordinates, descriptors = MongoDescriptor.get_data_as_arrays(
DatasetEnum.DATABASE)
log.info("Finished getting training data")
else:
log.info("Getting ids and coords for training data")
ids, coordinates = MongoDescriptor.get_ids_and_coords(
DatasetEnum.DATABASE)
descriptors = None
log.info("Finished getting training data")
log.debug(f"Current memory usage: {utils.get_memory_usage():.2f}GB")
log.info(f"Fitting model...")
model.fit(ids, coordinates, descriptors)
del ids, coordinates, descriptors
log.debug(f"Current memory usage: {utils.get_memory_usage():.2f}GB")
log.info(f"Model is trained.")
log.info(f"Getting query data")
q_ids, q_coordinates, q_descriptors = MongoDescriptor.get_data_as_arrays(
dataset=benchmark_params.query_dataset)
log.info("Finished getting query data")
log.debug(f"Current memory usage: {utils.get_memory_usage():.2f}GB")
log.info("Getting predictions...")
predicted_locations = model.predict(q_descriptors)
log.info("Finished getting predictions")
if benchmark_params.extended_results:
img_ids = q_ids
else:
img_ids = None
result = _get_benchmark_results(predicted_locations, q_coordinates,
img_ids)
if benchmark_params.save_result:
log.info("Saving test results")
with open(benchmark_params.save_path, 'w') as f:
json.dump(asdict(result), f)
return result
def get_index(index_config: IndexConfig) -> Index:
if index_config.index_dir is None:
log.info("Getting training data")
ids, coordinates, descriptors = MongoDescriptor.get_data_as_arrays(
DatasetEnum.DATABASE)
log.info("Finished getting training data")
index = IndexBuilder(index_config, descriptors, ids).build()
else:
index = IndexBuilder(index_config).build()
return index
def localisation_tuning(parameters: TuningParameters):
log.info("Getting ids and coords for training data")
ids, coordinates = MongoDescriptor.get_ids_and_coords(DatasetEnum.DATABASE)
log.info("Finished getting training data")
log.debug(f"Current memory usage: {utils.get_memory_usage():.2f}GB")
log.info(f"Getting query data")
q_ids, q_coordinates, q_descriptors = MongoDescriptor.get_data_as_arrays(
dataset=parameters.query_dataset)
log.info("Finished getting query data")
log.debug(f"Current memory usage: {utils.get_memory_usage():.2f}GB")
coord_map = LocalisationModel.compute_coordinate_map(ids, coordinates)
grid_tuples = _param_grid(parameters.grid)
parameters_name = parameters.grid.keys()
records = []
for index_config in parameters.index_configs:
for i, tup in enumerate(grid_tuples):
start = time.time()
experiment_parameters = _tuple_to_dict(parameters_name, tup)
log.info(
f"Tuning experiment: {i + 1}/{len(grid_tuples)}, index: {index_config.index_type.name}, "
f"parameters: {experiment_parameters}")
model_params = _params_from_tuple(parameters_name, tup,
parameters.default_parameters)
model = LocalisationModel(model_params.localisation_type,
index_config, model_params.sigma,
model_params.m, model_params.k,
model_params.num_workers)
model.fit_from_coord_map(coord_map)
predicted_locations = model.predict(q_descriptors)
result = _get_benchmark_results(predicted_locations, q_coordinates)
tuning_record = {
"index_type": index_config.index_type.value,
"parameters": experiment_parameters,
"accuracy": result.accuracy,
"errors": result.errors,
"predictions_by_dist": result.predictions_by_dist
}
records.append(tuning_record)
end = time.time()
log.info(f"Current iteration time: {end - start:.3f}s")
if (i + 1) % parameters.save_every == 0 or (i +
1) == len(grid_tuples):
log.info(
f"Saving tuning results. Step: {i + 1}/{len(grid_tuples)}, "
f"index: {index_config.index_type.name}, parameters: {experiment_parameters}"
)
_save_tuning_results(records, parameters.save_path)
log.info(f"Results saved to: {parameters.save_path}")
def create_and_save_index(index_config: IndexConfig, save_path):
log.info("Reading data from db...")
ids, coordinates, descriptors = MongoDescriptor.get_data_as_arrays(
DatasetEnum.DATABASE)
log.info("Finished reading data from db")
log.info("Building index...")
index = IndexBuilder(index_config, descriptors, ids).build()
log.info(f"Index built: {repr(index)}")
class_path = os.path.join(save_path, INDEX_CLASS_FILE)
log.info(f"Saving class file to {class_path}")
with open(class_path, "wb") as f:
index_config.index_dir = save_path
pickle.dump(index_config, f)
index_config.index_dir = None
index_path = os.path.join(save_path, INDEX_FILE_NAME)
log.info(f"Saving index file to {index_path}")
index.write_index(index_path)