feat: adjust confidence range in analysis result and optimize parallel processing for feature extraction, vocal analysis, and CLAP detection

app/routes/analyze.py

@@ -174,7 +174,7 @@ class AnalysisResult(BaseModel):
     """Platform/hooks/analysisTypes.ts uyumlu."""
 
     isAIGenerated: bool
-    confidence: float = Field(..., ge=0.0, le=1.0)
+    confidence: float = Field(..., ge=0.03, le=0.97)
     processingTime: float
     modelVersion: str
     decisionSource: str
@@ -333,11 +333,25 @@ async def _analyze_file(
     )
 
     warnings: List[str] = []
+    loop = asyncio.get_event_loop()
 
-    # ── Step 1: Feature extraction ────────────
+    # ── Run feature extraction + vocal analysis + CLAP in parallel ────
+    def _extract_features_sync():
+        return extract_features(io.BytesIO(content))
+
+    def _analyze_vocals_sync():
+        return analyze_vocals(io.BytesIO(content))
+
+    def _clap_predict_sync():
+        return clap_service.predict(io.BytesIO(content))
+
+    feat_future = loop.run_in_executor(_analysis_pool, _extract_features_sync)
+    vocal_future = loop.run_in_executor(_analysis_pool, _analyze_vocals_sync)
+    clap_future = loop.run_in_executor(_analysis_pool, _clap_predict_sync)
+
+    # Await feature extraction first (required for fusion)
     try:
-        audio_bytes = io.BytesIO(content)
-        features: AudioFeatures = extract_features(audio_bytes)
+        features: AudioFeatures = await feat_future
         logger.info(
             f"[{request_id}] Features: "
             f"S={features.spectral_regularity:.3f} "
@@ -345,30 +359,20 @@ async def _analyze_file(
             f"H={features.harmonic_structure:.3f}"
         )
     except ValueError as e:
-        logger.warning(
-            f"[{request_id}] Feature extraction "
-            f"failed: {e}"
-        )
+        logger.warning(f"[{request_id}] Feature extraction failed: {e}")
         return _fallback_analysis(
-            request_id, file, content,
-            file_size, start_time, str(e),
+            request_id, file, content, file_size, start_time, str(e),
         )
     except Exception as e:
-        logger.error(
-            f"[{request_id}] Feature extraction "
-            f"error: {e}", exc_info=True,
-        )
-        warnings.append("feature_extraction_partial")
+        logger.error(f"[{request_id}] Feature extraction error: {e}", exc_info=True)
         return _fallback_analysis(
-            request_id, file, content,
-            file_size, start_time, str(e),
+            request_id, file, content, file_size, start_time, str(e),
         )
 
-    # ── Step 2: Vocal analysis ──────────────
+    # Await vocal analysis (ran in parallel)
     vocals: Optional[VocalFeatures] = None
     try:
-        audio_bytes_vocal = io.BytesIO(content)
-        vocals = analyze_vocals(audio_bytes_vocal)
+        vocals = await vocal_future
         if vocals.has_vocals:
             logger.info(
                 f"[{request_id}] Vocals: "
@@ -381,11 +385,10 @@ async def _analyze_file(
         logger.warning(f"[{request_id}] Vocal analysis failed: {e}")
         warnings.append("vocal_analysis_unavailable")
 
-    # ── Step 3: CLAP detection (Layer 2) ────
+    # Await CLAP (ran in parallel)
     clap_result = None
     try:
-        audio_bytes_clap = io.BytesIO(content)
-        clap_result = clap_service.predict(audio_bytes_clap)
+        clap_result = await clap_future
         if clap_result.available:
             logger.info(
                 f"[{request_id}] CLAP: "
@@ -393,21 +396,15 @@ async def _analyze_file(
                 f"conf={clap_result.confidence:.3f}"
             )
         else:
-            logger.info(
-                f"[{request_id}] CLAP unavailable: "
-                f"{clap_result.error}"
-            )
+            logger.info(f"[{request_id}] CLAP unavailable: {clap_result.error}")
     except Exception as e:
-        logger.warning(
-            f"[{request_id}] CLAP failed: {e}"
-        )
+        logger.warning(f"[{request_id}] CLAP failed: {e}")
         warnings.append("clap_analysis_unavailable")
 
-    # ── Step 4: FST detection (Layer 3) ────
+    # FST detection (Layer 3) — async native
     fst_result = None
     try:
-        audio_bytes_fst = io.BytesIO(content)
-        fst_result = await fst_service.predict(audio_bytes_fst)
+        fst_result = await fst_service.predict(io.BytesIO(content))
         if fst_result.available:
             logger.info(
                 f"[{request_id}] FST: "
@@ -416,14 +413,9 @@ async def _analyze_file(
                 f"label={fst_result.label}"
             )
         else:
-            logger.info(
-                f"[{request_id}] FST unavailable: "
-                f"{fst_result.error}"
-            )
+            logger.info(f"[{request_id}] FST unavailable: {fst_result.error}")
     except Exception as e:
-        logger.warning(
-            f"[{request_id}] FST failed: {e}"
-        )
+        logger.warning(f"[{request_id}] FST failed: {e}")
         warnings.append("fst_analysis_unavailable")
 
     # ── Step 5: Score fusion ───────────────

app/training/wav2vec2_classifier.py

@@ -38,7 +38,7 @@ class Wav2Vec2Config:
     learning_rate_head: float = 1e-3
     learning_rate_encoder: float = 1e-5
     weight_decay: float = 0.01
-    batch_size: int = 8
+    batch_size: int = 2
     epochs: int = 10
     patience: int = 3
     device: str = "auto"