feat: add filters

Author: Yuyan-C

ami/main/models.py

@@ -2031,6 +2031,37 @@ def top_n(self, n: int = 3) -> list[dict[str, "Taxon | float | None"]]:
             for i, s in top_scored
         ]
 
+    def genus_scores_with_taxa(self) -> typing.Iterable[tuple[str, float]]:
+        """
+        Return the genus scores for this classification using the category map.
+        """
+        raise NotImplementedError
+        predictions = self.predictions_with_taxa()
+        genus_scores = {}
+        for taxon, score in predictions:
+            genus = taxon.get_parent(rank="GENUS")
+            if genus:
+                genus_scores[genus] = genus_scores.get(genus, 0) + score
+        return sorted(genus_scores.items(), key=lambda x: x[1], reverse=True)
+
+    def genus_scores_by_splitting_names(self) -> typing.Iterable[tuple["Taxon", float]]:
+        """
+        Return the genus scores for this classification using the category map.
+        """
+        predictions = self.predictions()
+        genus_scores = {}
+        for taxon_name, score in predictions:
+            genus_name = taxon_name.split(" ")[0]
+            if genus_name:
+                genus_scores[genus_name] = genus_scores.get(genus_name, 0) + score
+
+        # Get or make actual Taxon objects
+        genus_scores = {
+            Taxon.objects.get_or_create(name=genus_name, rank="GENUS")[0]: score
+            for genus_name, score in genus_scores.items()
+        }
+        return sorted(genus_scores.items(), key=lambda x: x[1], reverse=True)
+
     def get_similar_classifications(self, distance_metric="cosine") -> models.QuerySet:
         """
         Return  most similar classifications based on feature_2048 embeddings.

ami/ml/clustering_algorithms/agglomerative.py

@@ -70,6 +70,47 @@ def setup(self, data_dict):
                     data_dict["val"]["feat_list"], data_dict["val"]["label_list"]
                 )
 
+    def cluster_by_higher_taxon(self, features, rel_sizes, predictions, taxon_map, taxon_rank)-> tuple[np.ndarray, np.ndarray]:
+
+
+        # map labdls -> [species, genus, family]
+
+        # [1, 0, 4, 5, ...]
+        # [sp.1, sp.2, ...]
+        # [genus1, ]
+        # TODO: create taxon_mask based on predictions and taxon_map
+        taxons = taxon_map[predictions]
+
+        cluster_id_offset = 0
+
+        all_cluster_ids = []
+        all_silhouette_scores = []
+
+        for taxon in taxons:
+            taxon_features = features[predictions.isin(taxon)] #TODO: change this
+            taxon_rel_sizes = rel_sizes[predictions.isin(taxon)] #TODO: change this
+
+            cluster_ids, silhouette_scores = self.cluster(taxon_features, taxon_rel_sizes)
+            cluster_ids += cluster_id_offset
+
+            cluster_id_offset += len(np.unique(cluster_ids))
+
+            all_cluster_ids.append(cluster_ids)
+            all_silhouette_scores.append(silhouette_scores)
+
+        all_cluster_ids = np.concatenate(all_cluster_ids, axis=0)
+        all_silhouette_scores = np.concatenate(all_silhouette_scores, axis=0)
+
+        return all_cluster_ids, all_silhouette_scores
+
+
+
+
+
+
+
+
+
     def cluster(self, features, rel_sizes) -> tuple[np.ndarray, np.ndarray]:
         logger.info(f"distance threshold: {self.distance_threshold}")
         logger.info("features shape: %s", features.shape)

ami/ml/clustering_algorithms/cluster_detections.py

@@ -2,9 +2,11 @@
 import logging
 import typing
 
+# import cv2
 import numpy as np
 from django.db.models import Count
 from django.utils.timezone import now
+from PIL import Image
 
 from ami.ml.clustering_algorithms.utils import get_clusterer
 
@@ -85,6 +87,58 @@ def get_cluster_name(cluster_id: int, taxon: "Taxon | None" = None, job: "Job |
 
     return " ".join(part for part in parts if part)
 
+def remove_detection_on_edge(detection):
+
+    bbox = detection.bbox
+    img_width, img_height = detection.source_image.width, detection.source_image.height
+
+    # left
+    if bbox[0] < 1:
+        return True
+
+    # top
+    if bbox[1] < 1:
+        return True
+
+    # right
+    if bbox[2] > img_width - 2:
+        return True
+
+
+    if bbox[3] > img_height -2 :
+        return True
+
+    return False
+
+
+def get_relative_size(detection):
+    bbox_width, bbox_height = detection.width(), detection.height()
+    img_width, img_height = detection.source_image.width, detection.source_image.height
+    detection.source_image.deployment
+    assert img_width and img_height
+    relative_size = (bbox_width * bbox_height) / (img_width * img_height)
+    return relative_size
+
+def compute_sharpness(image_path):
+    image = Image.open(image_path).convert('L')
+    image_array = np.array(image, dtype=np.float32)
+
+    # Define Laplacian kernel
+    kernel = np.array([[0,  1, 0],
+                       [1, -4, 1],
+                       [0,  1, 0]], dtype=np.float32)
+
+    padded = np.pad(image_array, pad_width=1, mode='reflect')
+    laplacian = np.zeros_like(image_array)
+
+    for i in range(image_array.shape[0]):
+        for j in range(image_array.shape[1]):
+            region = padded[i:i+3, j:j+3]
+            laplacian[i, j] = np.sum(region * kernel)
+
+    laplacian_std = np.std(laplacian)
+
+    return laplacian_std
 
 def cluster_detections(
     collection, params: dict, task_logger: logging.Logger = logger, job=None
@@ -94,6 +148,9 @@ def cluster_detections(
     from ami.ml.models import Algorithm
     from ami.ml.models.pipeline import create_and_update_occurrences_for_detections
 
+    sharpness_threshold = 8
+    relative_size_threshold = 0.1 #  TODO: this should be updated
+
     ood_threshold = params.get("ood_threshold", 1)
     feature_extraction_algorithm = params.get("feature_extraction_algorithm", None)
     algorithm = params.get("clustering_algorithm", "agglomerative")
@@ -123,18 +180,28 @@ def cluster_detections(
     valid_classifications = []
     update_job_progress(job, stage_key="feature_collection", status=JobState.STARTED, progress=0.0)
     # Collecting features for detections
+
+
     for idx, detection in enumerate(detections):
+
         classification = detection.classifications.filter(
             features_2048__isnull=False,
             algorithm=feature_extraction_algorithm,
         ).first()
+
         if classification:
+            if remove_detection_on_edge(detection): # remove crops that are on the edge
+                continue
+            relative_size = get_relative_size(detection)
+
+            if relative_size < relative_size_threshold: # remove small crops
+                continue
+
+            sharpness = compute_sharpness(detection.path) # remove blurry images
+            if sharpness < sharpness_threshold:
+                continue
+
             features.append(classification.features_2048)
-            bbox_width, bbox_height = detection.width(), detection.height()
-            img_width, img_height = detection.source_image.width, detection.source_image.height
-            detection.source_image.deployment
-            assert img_width and img_height
-            relative_size = (bbox_width * bbox_height) / (img_width * img_height)
             sizes.append(relative_size)
             valid_detections.append(detection)
             valid_classifications.append(classification)
@@ -160,7 +227,7 @@ def cluster_detections(
     if not ClusteringAlgorithm:
         raise ValueError(f"Unsupported clustering algorithm: {algorithm}")
 
-    cluster_ids, cluster_scores = ClusteringAlgorithm(params).cluster(features_np, size_np)
+    cluster_ids, cluster_scores = ClusteringAlgorithm(params).cluster(features_np, size_np) # TODO: change this
 
     task_logger.info(f"Clustering completed with {len(set(cluster_ids))} clusters")
     clusters: dict[int, list[ClusterMember]] = {}

ami/ml/tests.py

@@ -24,7 +24,6 @@
     create_captures,
     create_captures_from_files,
     create_detections,
-    create_processing_service,
     create_taxa,
     group_images_into_events,
     setup_test_project,
@@ -732,6 +731,7 @@ def populate_collection_with_detections(self):
     def _populate_detection_features(self):
         """Populate detection features with random values."""
         classifier = Algorithm.objects.get(key="random-species-classifier")
+        taxon = Taxon.objects.last()
         for detection in self.detections:
             detection.associate_new_occurrence()
             # Create a random feature vector
@@ -740,7 +740,7 @@ def _populate_detection_features(self):
             classification = Classification.objects.create(
                 detection=detection,
                 algorithm=classifier,
-                taxon=None,
+                taxon=taxon,
                 score=0.5,
                 ood_score=0.5,
                 features_2048=feature_vector,