Is it possible to search for similarities in 3D files with artificial intelligence?

Question

I am doing an artificial intelligence study on 3D cam/cad files.

I give a stl file path as a parameter and the path to a folder with multiple stl files in it, and I look for similar stl files in the stl files in that folder. I visit the folder with the stl files in turn and decide whether they are similar according to the Hausdorff distance, which is mostly successful. But when I send the features and labels I extracted from here to my model, that is, when I train the model, when I want to test it later, the model always returns me the wrong result, for example, even when I compare the same 2 files, it tells me that they are not similar.

There are 36 stl files in the data I trained the model and 9 of them are similar and the rest are not similar, these similar ones are the ones that have been modified by playing with the size of the same stl file.

my code is here

def load_stl(file_path):
    return pv.read(file_path)


def align_meshes(mesh1, mesh2):
    # Get the points of each mesh
    points1 = mesh1.points
    points2 = mesh2.points

    # Calculate the centroids of each set of points
    centroid1 = np.mean(points1, axis=0)
    centroid2 = np.mean(points2, axis=0)

    # Center each set of points at the origin
    points1_centered = points1 - centroid1
    points2_centered = points2 - centroid2

    # Compute the rotation matrix using PCA
    pca1 = PCA().fit(points1_centered)
    pca2 = PCA().fit(points2_centered)
    rotation_matrix = np.dot(pca1.components_.T, pca2.components_)

    # Apply the rotation and translation to points2
    points2_aligned = np.dot(points2_centered, rotation_matrix) + centroid1

    # Create a new mesh for the aligned points
    mesh2_aligned = pv.PolyData(points2_aligned, mesh2.faces)

    return mesh2_aligned


def compare_stl_with_folder(stl_file, folder_path, threshold):
    stl_files = [
        os.path.join(folder_path, file)
        for file in os.listdir(folder_path)
        if file.endswith(".stl")
    ]
    similarity_labels = []
    features = []
    for file in stl_files:
        if file != stl_file:
            target_mesh = load_stl(stl_file)
            mesh = load_stl(file)

            # Align meshes
            aligned_mesh = align_meshes(target_mesh, mesh)

            # target_mesh.plot(text='target')
            # aligned_mesh.plot(text='search')

            # Hausdorff mesafesini hesapla
            distance_forward = distance.directed_hausdorff(
                target_mesh.points, aligned_mesh.points
            )[0]
            distance_backward = distance.directed_hausdorff(
                aligned_mesh.points, target_mesh.points
            )[0]
            hausdorff_distance = max(distance_forward, distance_backward)

            if hausdorff_distance <= threshold:
                similarity_label = 1
            else:
                similarity_label = 0

            similarity_labels.append(similarity_label)

            mesh1 = trimesh.load_mesh(stl_file)
            mesh2 = trimesh.load_mesh(file)

            surface_area = mesh1.area
            volume = mesh1.volume
            convexity = mesh1.is_convex

            aligned_surface_area = mesh2.area
            aligned_volume = mesh2.volume
            aligned_convexity = mesh2.is_convex

            feature = [
                surface_area,
                volume,
                convexity,
                aligned_surface_area,
                aligned_volume,
                aligned_convexity,
            ]
            features.append(feature)


    labels = np.array(similarity_labels)
    features = np.array(features)

    scaler = StandardScaler()
    features_scaled = scaler.fit_transform(features)

    X_train, X_test, y_train, y_test = train_test_split(features_scaled, labels, test_size=0.2, random_state=42)

    num_features = X_train.shape[1]

    model = Sequential()
    model.add(Dense(64, activation='relu', input_shape=(num_features,)))
    model.add(Dense(32, activation='relu'))
    model.add(Dense(1, activation='sigmoid'))

    model.compile(optimizer='adam',
                  loss='binary_crossentropy',
                  metrics=['accuracy'])
    class_weights = {0: 1, 1: 10}  # Adjust the weights based on your dataset
    model.fit(X_train, y_train, epochs=100, class_weight=class_weights)

    test_loss, test_acc = model.evaluate(X_test, y_test)

    # Get predicted probabilities
    y_pred_prob = model.predict(X_test)

    # Calculate precision-recall curve and AUC
    precision, recall, thresholds_pr = precision_recall_curve(y_test, y_pred_prob)
    pr_auc = average_precision_score(y_test, y_pred_prob)

    # Print the values of precision, recall, and thresholds_pr
    print("Precision:", precision)
    print("Recall:", recall)
    print("Thresholds (Precision-Recall):", thresholds_pr)

    # Find optimal threshold for precision-recall curve
    optimal_pr_threshold_index = np.argmax(precision - recall)

    if optimal_pr_threshold_index < len(thresholds_pr):
        optimal_pr_threshold = thresholds_pr[optimal_pr_threshold_index]
    else:
        optimal_pr_threshold = thresholds_pr[-1]  # Use the last threshold if index is out of bounds

    print("Optimal Threshold (Precision-Recall):", optimal_pr_threshold)

    y_pred = (y_pred_prob > 0.3).astype(int)  # Adjust the threshold as needed
    cm = confusion_matrix(y_test, y_pred)

    print("Confusion Matrix:")
    print(cm)

    print("Test Features:")
    print(X_test)
    print("Test Labels:")
    print(y_test)

    print('Test accuracy:', test_acc)
    print('Test loss:', test_loss)

    history = model.fit(X_train, y_train, epochs=100)
    print("Accuracy: ", history.history['accuracy'])

    tf.keras.models.save_model(model, 'my_model')


if __name__ == "__main__":
    threshold = 21.0
    stl_file = "C:\\Users\\ubit\\OneDrive\\Desktop\\stlfile\\a.stl"  
    folder_path = "C:\\Users\\ubit\\OneDrive\\Desktop\\stlfile"  
    compare_stl_with_folder(stl_file, folder_path, threshold)

this is how I train the model or I think I train the model xD I save the model I have trained and test it with other stl files I test it this way too, here is my code

def predict_similarity(model, target_file, search_file, threshold):
    target_mesh = load_stl(target_file)
    search_mesh = load_stl(search_file)

    # Align meshes
    aligned_mesh = align_meshes(target_mesh, search_mesh)

    distance_forward = distance.directed_hausdorff(
        target_mesh.points, aligned_mesh.points
    )[0]
    distance_backward = distance.directed_hausdorff(
        aligned_mesh.points, target_mesh.points
    )[0]
    hausdorff_distance = max(distance_forward, distance_backward)

    if hausdorff_distance <= threshold:
        similarity_label = 1
    else:
        similarity_label = 0

    # Extract features for prediction
    mesh1 = trimesh.load_mesh(target_file)
    mesh2 = trimesh.load_mesh(search_file)

    surface_area = mesh1.area
    volume = mesh1.volume
    convexity = mesh1.is_convex

    aligned_surface_area = mesh2.area
    aligned_volume = mesh2.volume
    aligned_convexity = mesh2.is_convex

    features = [
        surface_area,
        volume,
        convexity,
        aligned_surface_area,
        aligned_volume,
        aligned_convexity,
    ]

    # Make prediction using the trained model
    prediction = model.predict([features])

    return prediction[0], hausdorff_distance

if __name__ == "__main__":
    model = tf.keras.models.load_model('my_model')
    threshold = 21.0

    search_file = "C:\\Users\\ubit\\OneDrive\\Desktop\\stl_test\\9.STL" 
    stl_file = "C:\\Users\\ubit\\OneDrive\\Desktop\\stl_test\\9.STL"
    prediction, distance = predict_similarity(model, stl_file, search_file, threshold)

    print(f"prediction: {prediction}, Hausdorff distance: {distance}")

the result after the model training is completed appeared when testing the model

I tried the linear regression model and when I could not get results from it, I tried the svm model, but each time the model failed.