fix: Set new constants for clustering vectors from the new backend app

Signed-off-by: Marcel Klehr <mklehr@gmx.net>

Author: marcelklehr

composer.json

@@ -42,6 +42,7 @@
       "php": "8.2.0"
     },
     "allow-plugins": {
+      "bamarni/composer-bin-plugin": true,
       "composer/package-versions-deprecated": true
     },
     "autoloader-suffix": "Recognize",

lib/Classifiers/TaskProcessing/ImageFaceRecognitionClassifier.php

@@ -14,6 +14,16 @@
 use OCA\Recognize\TaskProcessing\ImageFaceRecognitionTaskType;
 
 final class ImageFaceRecognitionClassifier extends AbstractTaskProcessingClassifier {
+	const MIN_FACE_RECOGNITION_SCORE = 0.6;
+
+	public const MIN_DATASET_SIZE = 120;
+	public const MIN_DETECTION_SIZE = 0.03;
+	public const MIN_CLUSTER_SEPARATION = 0.7;
+	public const MAX_CLUSTER_EDGE_LENGTH = 1.0;
+	public const DIMENSIONS = 512;
+	public const MAX_OVERLAP_NEW_CLUSTER = 0.1;
+	public const MIN_OVERLAP_EXISTING_CLUSTER = 0.5;
+
 	protected function getTaskTypeId(): string {
 		return ImageFaceRecognitionTaskType::ID;
 	}

lib/Db/FaceDetectionMapper.php

@@ -7,7 +7,9 @@
 declare(strict_types=1);
 namespace OCA\Recognize\Db;
 
+use OCA\Recognize\Classifiers\TaskProcessing\ImageFaceRecognitionClassifier;
 use OCA\Recognize\Service\FaceClusterAnalyzer;
+use OCA\Recognize\Service\SettingsService;
 use OCP\AppFramework\Db\DoesNotExistException;
 use OCP\AppFramework\Db\Entity;
 use OCP\AppFramework\Db\QBMapper;
@@ -21,11 +23,20 @@
  */
 final class FaceDetectionMapper extends QBMapper {
 	private IConfig $config;
+	private SettingsService $settingsService;
 
-	public function __construct(IDBConnection $db, IConfig $config) {
+	public function __construct(IDBConnection $db, IConfig $config, SettingsService $settingsService) {
 		parent::__construct($db, 'recognize_face_detections', FaceDetection::class);
 		$this->db = $db;
 		$this->config = $config;
+		$this->settingsService = $settingsService;
+	}
+
+	private function getMinDetectionSize(): float {
+		if ($this->settingsService->getSetting('taskprocessing.enabled') === 'true') {
+			return ImageFaceRecognitionClassifier::MIN_DETECTION_SIZE;
+		}
+		return FaceClusterAnalyzer::MIN_DETECTION_SIZE;
 	}
 
 	/**
@@ -329,12 +340,13 @@ public function findDetectionForPreviewImageByClusterId(int $clusterId) : FaceDe
 	}
 
 	public function countUnclustered(): int {
+		$minDetectionSize = $this->getMinDetectionSize();
 		$qb = $this->db->getQueryBuilder();
 		$qb->select($qb->func()->count('id'))
 			->from('recognize_face_detections')
 			->where($qb->expr()->isNull('cluster_id'))
-			->andWhere($qb->expr()->gte('height', $qb->createPositionalParameter(FaceClusterAnalyzer::MIN_DETECTION_SIZE)))
-			->andWhere($qb->expr()->gte('width', $qb->createPositionalParameter(FaceClusterAnalyzer::MIN_DETECTION_SIZE)));
+			->andWhere($qb->expr()->gte('height', $qb->createPositionalParameter($minDetectionSize)))
+			->andWhere($qb->expr()->gte('width', $qb->createPositionalParameter($minDetectionSize)));
 		$result = $qb->executeQuery();
 		/** @var int|string $count */
 		$count = $result->fetch(\PDO::FETCH_COLUMN);
@@ -347,12 +359,13 @@ public function countUnclustered(): int {
 	 * @throws \OCP\DB\Exception
 	 */
 	public function getUsersForUnclustered(): array {
+		$minDetectionSize = $this->getMinDetectionSize();
 		$qb = $this->db->getQueryBuilder();
 		$qb->selectDistinct('user_id')
 			->from('recognize_face_detections')
 			->where($qb->expr()->isNull('cluster_id'))
-			->andWhere($qb->expr()->gte('height', $qb->createPositionalParameter(FaceClusterAnalyzer::MIN_DETECTION_SIZE)))
-			->andWhere($qb->expr()->gte('width', $qb->createPositionalParameter(FaceClusterAnalyzer::MIN_DETECTION_SIZE)));
+			->andWhere($qb->expr()->gte('height', $qb->createPositionalParameter($minDetectionSize)))
+			->andWhere($qb->expr()->gte('width', $qb->createPositionalParameter($minDetectionSize)));
 		$result = $qb->executeQuery();
 		/** @var array<string> $users */
 		$users = $result->fetchAll(\PDO::FETCH_COLUMN);

lib/Service/FaceClusterAnalyzer.php

@@ -9,6 +9,7 @@
 
 use \OCA\Recognize\Vendor\Rubix\ML\Datasets\Labeled;
 use \OCA\Recognize\Vendor\Rubix\ML\Kernels\Distance\Euclidean;
+use OCA\Recognize\Classifiers\TaskProcessing\ImageFaceRecognitionClassifier;
 use OCA\Recognize\Clustering\HDBSCAN;
 use OCA\Recognize\Db\FaceCluster;
 use OCA\Recognize\Db\FaceClusterMapper;
@@ -27,14 +28,35 @@ final class FaceClusterAnalyzer {
 	private FaceDetectionMapper $faceDetections;
 	private FaceClusterMapper $faceClusters;
 	private Logger $logger;
-	private int $minDatasetSize = self::MIN_DATASET_SIZE;
+	private int $minDatasetSize;
+	private float $minDetectionSize;
+	private float $minClusterSeparation;
+	private float $maxClusterEdgeLength;
+	private float $maxOverlapNewCluster;
+	private float $minOverlapExistingCluster;
 	private SettingsService $settingsService;
 
 	public function __construct(FaceDetectionMapper $faceDetections, FaceClusterMapper $faceClusters, Logger $logger, SettingsService $settingsService) {
 		$this->faceDetections = $faceDetections;
 		$this->faceClusters = $faceClusters;
 		$this->logger = $logger;
 		$this->settingsService = $settingsService;
+
+		if ($this->settingsService->getSetting('taskprocessing.enabled') === 'true') {
+			$this->minDatasetSize = ImageFaceRecognitionClassifier::MIN_DATASET_SIZE;
+			$this->minDetectionSize = ImageFaceRecognitionClassifier::MIN_DETECTION_SIZE;
+			$this->minClusterSeparation = ImageFaceRecognitionClassifier::MIN_CLUSTER_SEPARATION;
+			$this->maxClusterEdgeLength = ImageFaceRecognitionClassifier::MAX_CLUSTER_EDGE_LENGTH;
+			$this->maxOverlapNewCluster = ImageFaceRecognitionClassifier::MAX_OVERLAP_NEW_CLUSTER;
+			$this->minOverlapExistingCluster = ImageFaceRecognitionClassifier::MIN_OVERLAP_EXISTING_CLUSTER;
+		} else {
+			$this->minDatasetSize = self::MIN_DATASET_SIZE;
+			$this->minDetectionSize = self::MIN_DETECTION_SIZE;
+			$this->minClusterSeparation = self::MIN_CLUSTER_SEPARATION;
+			$this->maxClusterEdgeLength = self::MAX_CLUSTER_EDGE_LENGTH;
+			$this->maxOverlapNewCluster = self::MAX_OVERLAP_NEW_CLUSTER;
+			$this->minOverlapExistingCluster = self::MIN_OVERLAP_EXISTING_CLUSTER;
+		}
 	}
 
 	public function setMinDatasetSize(int $minSize) : void {
@@ -64,12 +86,12 @@ public function calculateClusters(string $userId, int $batchSize = 0): void {
 		}
 
 		if ($batchSize > 0) {
-			$rejectedDetections = $this->faceDetections->sampleRejectedDetectionsByUserId($userId, $this->getRejectSampleSize($batchSize), self::MIN_DETECTION_SIZE, self::MIN_DETECTION_SIZE);
+			$rejectedDetections = $this->faceDetections->sampleRejectedDetectionsByUserId($userId, $this->getRejectSampleSize($batchSize), $this->minDetectionSize, $this->minDetectionSize);
 			$requestedFreshDetectionCount = max($batchSize - count($rejectedDetections) - count($sampledDetections), 500);
-			$freshDetections = $this->faceDetections->findUnclusteredByUserId($userId, $requestedFreshDetectionCount, self::MIN_DETECTION_SIZE, self::MIN_DETECTION_SIZE);
+			$freshDetections = $this->faceDetections->findUnclusteredByUserId($userId, $requestedFreshDetectionCount, $this->minDetectionSize, $this->minDetectionSize);
 		} else {
-			$freshDetections = $this->faceDetections->findUnclusteredByUserId($userId, 0, self::MIN_DETECTION_SIZE, self::MIN_DETECTION_SIZE);
-			$rejectedDetections = $this->faceDetections->sampleRejectedDetectionsByUserId($userId, $this->getRejectSampleSize(count($freshDetections)), self::MIN_DETECTION_SIZE, self::MIN_DETECTION_SIZE);
+			$freshDetections = $this->faceDetections->findUnclusteredByUserId($userId, 0, $this->minDetectionSize, $this->minDetectionSize);
+			$rejectedDetections = $this->faceDetections->sampleRejectedDetectionsByUserId($userId, $this->getRejectSampleSize(count($freshDetections)), $this->minDetectionSize, $this->minDetectionSize);
 		}
 
 
@@ -94,7 +116,7 @@ public function calculateClusters(string $userId, int $batchSize = 0): void {
 		$hdbscan = new HDBSCAN($dataset, $this->getMinClusterSize($n), $this->getMinSampleSize($n));
 
 		$numberOfClusteredDetections = 0;
-		$clusters = $hdbscan->predict(self::MIN_CLUSTER_SEPARATION, self::MAX_CLUSTER_EDGE_LENGTH);
+		$clusters = $hdbscan->predict($this->minClusterSeparation, $this->maxClusterEdgeLength);
 
 		foreach ($clusters as $flatCluster) {
 			/** @var int[] $detectionKeys */
@@ -132,10 +154,10 @@ public function calculateClusters(string $userId, int $batchSize = 0): void {
 			}
 
 			// If more than X% of already clustered detections are for this, we keep it
-			if ($overlap > self::MIN_OVERLAP_EXISTING_CLUSTER) {
+			if ($overlap > $this->minOverlapExistingCluster) {
 				$clusterId = $oldClusterId;
 				$cluster = $this->faceClusters->find($clusterId);
-			} elseif ($overlap < self::MAX_OVERLAP_NEW_CLUSTER) {
+			} elseif ($overlap < $this->maxOverlapNewCluster) {
 				// otherwise we create a new cluster
 
 				$cluster = new FaceCluster();
@@ -187,17 +209,21 @@ public function calculateClusters(string $userId, int $batchSize = 0): void {
 	 * @return list<float>
 	 */
 	public static function calculateCentroidOfDetections(array $detections): array {
-		// init 128 dimensional vector
-		/** @var list<float> $sum */
-		$sum = [];
-		for ($i = 0; $i < self::DIMENSIONS; $i++) {
-			$sum[] = 0.0;
-		}
-
 		if (count($detections) === 0) {
-			return $sum;
+			/** @var list<float> $empty */
+			$empty = [];
+			for ($i = 0; $i < self::DIMENSIONS; $i++) {
+				$empty[] = 0.0;
+			}
+			return $empty;
 		}
 
+		// Size the accumulator from the first detection so both 128-dim (legacy) and
+		// 512-dim (buffalo_l/taskprocessing) embeddings work without a runtime switch.
+		$dimensions = count(reset($detections)->getVector());
+		/** @var list<float> $sum */
+		$sum = array_fill(0, $dimensions, 0.0);
+
 		foreach ($detections as $detection) {
 			$sum = array_map(static function (float $el, float $el2): float {
 				return $el + $el2;

lib/TaskProcessing/TaskResultListener.php

@@ -15,6 +15,7 @@
 use OCA\Recognize\Classifiers\Images\ClusteringFaceClassifier;
 use OCA\Recognize\Classifiers\Images\ImagenetClassifier;
 use OCA\Recognize\Classifiers\Images\LandmarksClassifier;
+use OCA\Recognize\Classifiers\TaskProcessing\ImageFaceRecognitionClassifier;
 use OCA\Recognize\Classifiers\Video\MovinetClassifier;
 use OCA\Recognize\Db\FaceDetection;
 use OCA\Recognize\Db\FaceDetectionMapper;
@@ -27,9 +28,11 @@
 use OCP\EventDispatcher\IEventListener;
 use OCP\Files\Config\ICachedMountInfo;
 use OCP\Files\Config\IUserMountCache;
+use OCP\IUserManager;
 use OCP\TaskProcessing\Events\TaskFailedEvent;
 use OCP\TaskProcessing\Events\TaskSuccessfulEvent;
 use OCP\TaskProcessing\Task;
+use OCP\IUserSession;
 use Psr\Log\LoggerInterface;
 
 /**
@@ -49,6 +52,8 @@ public function __construct(
 		private IAppConfig $config,
 		private IJobList $jobList,
 		private QueueService $queue,
+		private IUserSession $userSession,
+		private IUserManager $userManager,
 	) {
 	}
 
@@ -90,6 +95,8 @@ private function handleSuccess(TaskSuccessfulEvent $event): void {
 		$fileIds = array_map('intval', array_values($input));
 		$results = array_values($output);
 
+		$this->userSession->setUser($this->userManager->get($task->getUserId()));
+
 		switch ($task->getTaskTypeId()) {
 			case ImageClassificationTaskType::ID:
 				$this->applyTagResults($fileIds, $results, ImagenetClassifier::MODEL_NAME, false);
@@ -188,13 +195,7 @@ private function applyFaceResults(array $fileIds, array $results): void {
 				if (!is_array($face)) {
 					continue;
 				}
-				if (isset($face['score']) && (float)$face['score'] < ClusteringFaceClassifier::MIN_FACE_RECOGNITION_SCORE) {
-					continue;
-				}
-				if (isset($face['angle']['roll'], $face['angle']['yaw'])
-					&& (abs((float)$face['angle']['roll']) > ClusteringFaceClassifier::MAX_FACE_ROLL
-						|| abs((float)$face['angle']['yaw']) > ClusteringFaceClassifier::MAX_FACE_YAW)
-				) {
+				if (isset($face['score']) && (float)$face['score'] < ImageFaceRecognitionClassifier::MIN_FACE_RECOGNITION_SCORE) {
 					continue;
 				}
 				// Accept either a full face object {x,y,width,height,score,vector,angle}