def test_pcd_subsampling_random(self):
"""
Tests random sequential_skip.
"""
pointcloud_original = self.get_pointcloud()
for subsampling_size in subsampling_sizes:
pointcloud_subsampled = subsample_pointcloud(
pointcloud_original, subsampling_size, "sequential_skip")
self.assertEqual(len(pointcloud_subsampled), subsampling_size)
def process_artifacts(artifacts):
# Create database connection.
db_connector = dbutils.connect_to_main_database()
# Load the model first.
model = load_model(model_path)
model_name = model_path.split("/")[-2]
# Evaluate and create SQL-statements.
bar = progressbar.ProgressBar(max_value=len(artifacts))
for artifact_index, artifact in enumerate(artifacts):
bar.update(artifact_index)
# Execute SQL statement.
try:
# Load the artifact and evaluate.
artifact_id, pcd_path, target_height, qrcode = artifact
pcd_array = utils.load_pcd_as_ndarray(pcd_path)
pcd_array = utils.subsample_pointcloud(pcd_array, 10000)
mse, mae = model.evaluate(np.expand_dims(pcd_array, axis=0),
np.array([target_height]),
verbose=0)
if qrcode in qrcodes_train:
misc = "training"
else:
misc = "nottraining"
# Create an SQL statement.
sql_statement = ""
sql_statement += "INSERT INTO artifact_quality (type, key, value, artifact_id, misc)"
sql_statement += " VALUES(\'{}\', \'{}\', \'{}\', \'{}\', \'{}\');".format(
model_name, "mae", mae, artifact_id, misc)
# Call database.
result = db_connector.execute(sql_statement)
except psycopg2.IntegrityError:
print("Already in DB. Skipped.", pcd_path)
except ValueError:
print("Skipped.", pcd_path)
bar.finish()
def test_pcd_subsampling_first(self):
"""
Tests first subsampling.
"""
pointcloud_original = self.get_pointcloud()
# Generate some pointclouds and check if target_size is met.
pointclouds = []
for subsampling_size in subsampling_sizes:
pointcloud_subsampled = subsample_pointcloud(
pointcloud_original, subsampling_size, "first")
self.assertEqual(len(pointcloud_subsampled), subsampling_size)
pointclouds.append(pointcloud_subsampled)
# See if the pointclouds have the same first n elements.
for pointcloud1, pointcloud2 in zip(pointclouds[0:], pointclouds[1:]):
min_length = min(len(pointcloud1), len(pointcloud2))
self.assertTrue(min_length != 0)
self.assertTrue(
np.array_equal(pointcloud1[:min_length],
pointcloud2[:min_length]))
def process_artifacts(artifacts, process_index):
# Create database connection.
db_connector = dbutils.connect_to_main_database()
# Load the model first.
model_weights_path = [
x for x in glob.glob((os.path.join(model_path, "*")))
if x.endswith("-model-weights.h5")
][0]
model_details_path = [
x for x in glob.glob((os.path.join(model_path, "*")))
if x.endswith("-details.p")
][0]
model_name = model_path.split("/")[-1]
model_details = pickle.load(open(model_details_path, "rb"))
pointcloud_target_size = model_details["dataset_parameters"][
"pointcloud_target_size"]
pointcloud_subsampling_method = model_details["dataset_parameters"][
"pointcloud_subsampling_method"]
target_key = model_details["dataset_parameters"]["output_targets"][0]
model = load_model(model_weights_path, pointcloud_target_size)
# Evaluate and create SQL-statements.
for artifact_index, artifact in enumerate(
tqdm(artifacts, position=process_index)):
# Unpack fields.
artifact_id, pcd_path = artifact
# Check if there is already an entry.
select_sql_statement = ""
select_sql_statement += "SELECT COUNT(*) FROM artifact_result"
select_sql_statement += " WHERE artifact_id='{}'".format(
artifact_id)
select_sql_statement += " AND model_name='{}'".format(model_name)
select_sql_statement += " AND target_key='{}'".format(target_key)
results = db_connector.execute(select_sql_statement,
fetch_one=True)[0]
# There is an entry. Skip
if results != 0:
continue
# Execute SQL statement.
try:
# Load the artifact and evaluate.
pcd_path = pcd_path.replace("/whhdata/qrcode",
"/localssd/qrcode")
pcd_array = utils.load_pcd_as_ndarray(pcd_path)
pcd_array = utils.subsample_pointcloud(
pcd_array,
pointcloud_target_size,
subsampling_method=pointcloud_subsampling_method)
value = model.predict(np.expand_dims(pcd_array, axis=0),
verbose=0)[0][0]
# Create an SQL statement.
sql_statement = ""
sql_statement += "INSERT INTO artifact_result (model_name, target_key, value, artifact_id)"
sql_statement += " VALUES(\'{}\', \'{}\', \'{}\', \'{}\');".format(
model_name, target_key, value, artifact_id)
# Call database.
result = db_connector.execute(sql_statement)
except psycopg2.IntegrityError as e:
#print("Already in DB. Skipped.", pcd_path)
pass
except ValueError as e:
#print("Skipped.", pcd_path)
pass
def store_results(scan_path, db_connection_file, destination_folder):
#db_connection_file = str(sys.argv[2])
#destination_folder = str(sys.argv[3])
# Get the path to the scan.
#scan_path = sys.argv[1]
scan_path_split = scan_path.split("/")
scan_qrcode = scan_path_split[-3]
scan_timestamp = scan_path_split[-1]
# Get the paths to the artifacts.
glob_search_path = os.path.join(scan_path, "pc", "*.pcd")
pcd_paths = glob.glob(glob_search_path)
if len(pcd_paths) == 0:
print("No artifacts found. Aborting...")
exit(1)
# Prepare results dictionary.
results = Bunch()
results.scan = Bunch()
results.scan.qrcode = scan_qrcode
results.scan.timestamp = scan_timestamp
results.model_results = []
main_connector = dbutils.connect_to_main_database(db_connection_file)
# Select models from model table where active=True in json_metadata
select_models = "SELECT * FROM model WHERE (json_metadata->>'active')::BOOLEAN IS true;"
models = main_connector.execute(select_models, fetch_all=True)
# Go through the models from the models-file.
#with open("/home/mmatiaschek/whhdata/models.json") as json_file:
for model in models:
model_name = model[0]
# Locate the weights of the model.
weights_search_path = os.path.join("/home/smahale/whhdata/models",
model_name, "*")
weights_paths = [
x for x in glob.glob(weights_search_path) if "-weights" in x
]
if len(weights_paths) == 0:
continue
weights_path = weights_paths[0]
entry = model[3]
# Get the model parameters.
input_shape = entry["input_shape"]
output_size = entry["output_size"]
hidden_sizes = entry["hidden_sizes"]
#hidden_sizes = [512, 256, 128]
subsampling_method = entry["subsampling_method"]
# Load the model.
#print(weights_path, input_shape, output_size, hidden_sizes)
try:
model = modelutils.load_pointnet(weights_path, input_shape,
output_size, hidden_sizes)
except:
print("Failed!", weights_path)
continue
#print("Worked!", weights_path)
# Prepare the pointclouds.
pointclouds = []
for pcd_path in pcd_paths:
pointcloud = utils.load_pcd_as_ndarray(pcd_path)
pointcloud = utils.subsample_pointcloud(
pointcloud,
target_size=input_shape[0],
subsampling_method="sequential_skip")
pointclouds.append(pointcloud)
pointclouds = np.array(pointclouds)
# Predict.
predictions = model.predict(pointclouds)
# Prepare model result.
model_result = Bunch()
model_result.model_name = model_name
# Store measure result.
model_result.measure_result = Bunch()
model_result.measure_result.mean = str(np.mean(predictions))
model_result.measure_result.min = str(np.min(predictions))
model_result.measure_result.max = str(np.max(predictions))
model_result.measure_result.std = str(np.std(predictions))
# Store artifact results.
model_result.artifact_results = []
for pcd_path, prediction in zip(pcd_paths, predictions):
artifact_result = Bunch()
#artifact_result.path = pcd_path
artifact_result.path = '/'.join(pcd_path.split('/')[4:])
artifact_result.prediction = str(prediction[0])
model_result.artifact_results.append(artifact_result)
results.model_results.append(model_result)
results_json_string = json.dumps(results)
#print(results_json_string)
results_json_object = json.loads(results_json_string)
filename = "{0}/{1}-{2}-{3}-{4}.json".format(destination_folder,
pcd_paths[0].split('/')[3],
scan_qrcode, scan_timestamp,
random.randint(10000, 99999))
# Add the results to a json file in destination_folder
with open(filename, 'w') as json_file:
json.dump(results_json_object, json_file, indent=2)