multi models workflow

backend/app/api/routes.py

@@ -99,7 +99,7 @@ async def save_discord_guild_setup(guild_id: str, payload: GuildConfigSchema):
     return {
         "status": "success",
         "message": f"Konfiguracja dla serwera {guild_id} została zapisana.",
-        "config": config_dict
+        "config": config_dict,
     }
 
 @router.get("/guilds/{guild_id}/config", tags=["Setup"])
@@ -111,7 +111,8 @@ async def get_discord_guild_config(guild_id: str):
     return {
         "active_text_model": guild_config.get("active_text_model", "none"),
         "active_image_model": guild_config.get("active_image_model", "none"),
-        "log_channel_id": guild_config.get("log_channel_id", None)
+        "log_channel_id": guild_config.get("log_channel_id", None),
+        "multi_model_workflow": guild_config.get("multi_model_workflow", False)
     }
 
 async def _execute_analysis(payload: AnalysisRequest, guild_id: str, settings) -> dict:
@@ -222,4 +223,5 @@ async def analyze(request: Request, payload: AnalysisRequest) -> AnalysisRespons
         analysis_time=analysis_result["analysis_time"],
         used_model=used_model,
         content_type=content_type,
+        details=analysis_result.get("details"),
     )

backend/app/config_manager.py

@@ -51,4 +51,10 @@ def get_active_image_model(guild_id: str) -> Optional[str]:
     
     if not model or model.lower() == "none":
         return None
-    return model
+    return model
+
+def is_multi_model_enabled(guild_id: str) -> bool:
+    """Sprawdza, czy dla danej gildii włączony jest tryb wielomodelowy."""
+    configs = _load_all_configs()
+    guild_config = configs.get(guild_id, {})
+    return guild_config.get("multi_model_workflow", False)

backend/app/models/schemas.py

@@ -38,13 +38,18 @@ AnalysisRequest = Union[
     ImageAnalysisRequest
 ]
 
-
+class ModelDetail(BaseModel):
+    model: str
+    is_deepfake: bool
+    confidence: float
+    
 class AnalysisResponse(BaseModel):
     is_deepfake: bool = Field(..., description="Whether the content is detected as a deepfake")
     confidence: float = Field(..., ge=0.0, le=1.0, description="Confidence score between 0.0 and 1.0")
     analysis_time: float = Field(..., description="Time taken for analysis in seconds")
     used_model: str = Field(..., description="The detector model that was used")
     content_type: str = Field(..., description="Type of content analyzed (text/image/video/file)")
+    details: Optional[List[ModelDetail]] = None
     
     class Config:
         json_schema_extra = {
@@ -53,7 +58,10 @@ class AnalysisResponse(BaseModel):
                 "confidence": 0.847,
                 "analysis_time": 1.234,
                 "used_model": "mock",
-                "content_type": "image"
+                "content_type": "image",
+                "details": [
+                    {"model": "mock", "is_deepfake": True, "confidence": 0.847}
+                ]
             }
         }
 
@@ -91,3 +99,4 @@ class GuildConfigSchema(BaseModel):
     active_text_model: Optional[str] = "none"
     active_image_model: Optional[str] = "none"
     log_channel_id: Optional[str] = None
+    multi_model_workflow: Optional[bool] = False

backend/app/services/image_analyzer.py

@@ -6,81 +6,110 @@ from typing import Dict, Any
 from PIL import Image
 from transformers import pipeline
 
-# Importujemy helper do konfiguracji oraz wyjątek braku konfiguracji
-from app.config_manager import get_active_image_model
+from app.config_manager import get_active_image_model, is_multi_model_enabled
+from app.core.config import get_settings
 from app.utils.exceptions import SetupRequiredError
 
 logger = logging.getLogger(__name__)
 
-# Przechowujemy referencje do aktualnie załadowanego modelu obrazów
-_loaded_model_name = None
-_image_classifier = None
+_loaded_classifiers = {}
 
 def _load_model(target_model_name: str):
-    global _image_classifier, _loaded_model_name
+    global _loaded_classifiers
     
-    # Jeśli model o tej nazwie jest już załadowany w pamięci, używamy go ponownie
-    if _image_classifier is not None and _loaded_model_name == target_model_name:
-        return _image_classifier
+    if target_model_name in _loaded_classifiers:
+        return _loaded_classifiers[target_model_name]
         
-    logger.info(f"Wymagana zmiana modelu obrazu. Obecny w RAM: {_loaded_model_name}, Nowy: {target_model_name}")
+    logger.info(f"Model {target_model_name} nie jest załadowany. Ładowanie do RAM...")
     
-    # Czyszczenie pamięci po poprzednim modelu obrazów
-    _image_classifier = None
     gc.collect()
-    
-    logger.info(f"Ładowanie modelu image detector: {target_model_name}...")
-    _image_classifier = pipeline(
+    _loaded_classifiers[target_model_name] = pipeline(
         "image-classification",
         model=target_model_name,
-        device=-1  # -1 oznacza CPU
+        device=-1
     )
-    _loaded_model_name = target_model_name
     logger.info(f"Model {target_model_name} został pomyślnie załadowany.")
     
-    return _image_classifier
+    return _loaded_classifiers[target_model_name]
 
 async def analyze_image(image_bytes: bytes, guild_id: str) -> Dict[str, Any]:
     start_time = time.time()
+    settings = get_settings()
     
-    # 1. Sprawdzamy konfigurację modelu dla danego serwera Discord
-    active_model = get_active_image_model(guild_id)
-    
-    # BLOKADA: Jeżeli model to 'none' lub brak konfiguracji, natychmiast przerywamy i zgłaszamy błąd
-    if not active_model:
-        logger.warning(f"Zablokowano zapytanie! Serwer {guild_id} nie ma skonfigurowanego modelu dla obrazów.")
-        raise SetupRequiredError(
-            f"Serwer o ID '{guild_id}' nie został jeszcze skonfigurowany pod kątem analizy obrazów. "
-            "Użyj komendy setup na Discordzie przed wykonaniem analizy."
-        )
-
-    logger.info(f"Starting image analysis for guild: {guild_id}, model: {active_model}, size: {len(image_bytes)} bytes")
+    multi_model_active = is_multi_model_enabled(guild_id)
     
     try:
         image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
     except Exception as e:
         logger.error(f"Failed to parse image bytes: {str(e)}")
         raise ValueError("Invalid image format or corrupted bytes") from e
-    
-    # 2. Dynamicznie pobieramy/ładujemy wskazany model
-    classifier = _load_model(active_model)
-    result = classifier(image)
-    
-    label = result[0]["label"]
-    score = result[0]["score"]
-    
-    # Dostosowanie do najczęstszych etykiet fałszywych obrazów (np. "fake", "ai", "synthetic")
-    is_deepfake = label.lower() in ["fake", "ai", "synthetic", "label_1"]
-    confidence = score
-    
-    analysis_time = time.time() - start_time
-    
-    response = {
-        "is_deepfake": is_deepfake,
-        "confidence": round(confidence, 3),
-        "analysis_time": round(analysis_time, 3),
-        "used_model": active_model,
-    }
-    
-    logger.info(f"Image analysis completed. Result: {response}")
-    return response
+
+    if multi_model_active:
+        models_to_run = settings.AVAILABLE_MODELS.get("image", [])
+        if not models_to_run:
+            raise ValueError("Brak zdefiniowanych modeli obrazów w ustawieniach systemu.")
+            
+        logger.info(f"Wielomodelowa analiza obrazu dla serwera {guild_id} ({len(models_to_run)} modeli)")
+        
+        individual_results = []
+        for m in models_to_run:
+            try:
+                classifier = _load_model(m)
+                result = classifier(image)
+                label = result[0]["label"]
+                score = result[0]["score"]
+                is_fake = label.lower() in ["fake", "ai", "synthetic", "label_1"]
+                
+                individual_results.append({
+                    "model": m,
+                    "is_deepfake": is_fake,
+                    "confidence": round(score, 3)
+                })
+            except Exception as e:
+                logger.error(f"Błąd modelu {m} podczas wielomodelowej analizy obrazu: {e}")
+                
+        if not individual_results:
+            raise ValueError("Żaden z modeli obrazów nie dokonał pomyślnej analizy.")
+            
+        fake_votes = sum(1 for r in individual_results if r["is_deepfake"])
+        is_deepfake = fake_votes > (len(individual_results) / 2)
+        
+        confidence = sum(r["confidence"] for r in individual_results) / len(individual_results)
+        analysis_time = time.time() - start_time
+        
+        return {
+            "is_deepfake": is_deepfake,
+            "confidence": round(confidence, 3),
+            "analysis_time": round(analysis_time, 3),
+            "used_model": "Multi-Model Workflow (Ensemble)",
+            "details": individual_results
+        }
+        
+    else:
+        active_model = get_active_image_model(guild_id)
+        if not active_model:
+            logger.warning(f"Zablokowano zapytanie! Serwer {guild_id} nie ma skonfigurowanego modelu dla obrazów.")
+            raise SetupRequiredError(
+                f"Serwer o ID '{guild_id}' nie został jeszcze skonfigurowany pod kątem analizy obrazów. "
+                "Użyj komendy setup na Discordzie przed wykonaniem analizy."
+            )
+
+        logger.info(f"Starting image analysis for guild: {guild_id}, model: {active_model}, size: {len(image_bytes)} bytes")
+        
+        classifier = _load_model(active_model)
+        result = classifier(image)
+        
+        label = result[0]["label"]
+        score = result[0]["score"]
+        
+        is_deepfake = label.lower() in ["fake", "ai", "synthetic", "label_1"]
+        confidence = score
+        analysis_time = time.time() - start_time
+        
+        return {
+            "is_deepfake": is_deepfake,
+            "confidence": round(confidence, 3),
+            "analysis_time": round(analysis_time, 3),
+            "used_model": active_model,
+            "details": None
+        }

backend/app/services/text_analyzer.py

@@ -3,74 +3,110 @@ import time
 import gc
 from typing import Dict, Any
 
-from app.config_manager import get_active_text_model
+from app.config_manager import get_active_text_model, is_multi_model_enabled
+from app.core.config import get_settings
 from app.utils.exceptions import SetupRequiredError
 from transformers import pipeline
-# Importujesz helpery z Kroku 2:
-# from config_manager import get_active_text_model 
 
 logger = logging.getLogger(__name__)
 
-# Przechowujemy nazwę aktualnie załadowanego modelu oraz sam obiekt klasyfikatora
-_loaded_model_name = None
-_text_classifier = None
+# Słownik do keszowania klasyfikatorów w RAM (zapobiega ciągłemu przeładowywaniu przy multi-modelu)
+_loaded_classifiers = {}
 
 def _load_model(target_model_name: str):
-    global _text_classifier, _loaded_model_name
+    global _loaded_classifiers
     
-    # Jeśli model w pamięci jest tym, którego potrzebujemy, po prostu go zwracamy
-    if _text_classifier is not None and _loaded_model_name == target_model_name:
-        return _text_classifier
+    if target_model_name in _loaded_classifiers:
+        return _loaded_classifiers[target_model_name]
         
-    logger.info(f"Wymagana zmiana modelu. Obecny w RAM: {_loaded_model_name}, Nowy: {target_model_name}")
+    logger.info(f"Model {target_model_name} nie jest załadowany. Ładowanie do RAM...")
     
-    # Zwalnianie pamięci po poprzednim modelu
-    _text_classifier = None
     gc.collect()
-    
-    logger.info(f"Ładowanie modelu text detector: {target_model_name}...")
-    _text_classifier = pipeline(
+    _loaded_classifiers[target_model_name] = pipeline(
         "text-classification",
         model=target_model_name,
-        device=-1  # -1 oznacza CPU, jeśli masz GPU ustaw np. 0
+        device=-1
     )
-    _loaded_model_name = target_model_name
     logger.info(f"Model {target_model_name} został pomyślnie załadowany.")
     
-    return _text_classifier
+    return _loaded_classifiers[target_model_name]
 
 async def analyze_text(text: str, guild_id: str) -> Dict[str, Any]:
     start_time = time.time()
+    settings = get_settings()
     
-    # Pobranie aktywnego modelu dla danej gildii
-    active_model = get_active_text_model(guild_id)
-    
-    # BLOKADA: Jeżeli model to 'none' lub brak konfiguracji, natychmiast wyrzucamy błąd
-    if not active_model:
-        logger.warning(f"Zablokowano zapytanie! Serwer {guild_id} nie ma skonfigurowanego modelu.")
-        raise SetupRequiredError(
-            f"Serwer o ID '{guild_id}' nie został jeszcze skonfigurowany. "
-            "Użyj komendy setup na Discordzie przed wykonaniem analizy."
-        )
-
-    logger.info(f"Rozpoczęcie analizy tekstu dla serwera {guild_id} przy użyciu modelu: {active_model}")
-    
-    classifier = _load_model(active_model)
-    result = classifier(text)
+    # Sprawdzamy, czy włączony jest tryb wielomodelowy
+    multi_model_active = is_multi_model_enabled(guild_id)
     
-    label = result[0]["label"]
-    score = result[0]["score"]
-    
-    is_deepfake = label.lower() in ["fake", "ai", "chatgpt", "label_1", "machine-generated"]
-    confidence = score
-    analysis_time = time.time() - start_time
-    
-    response = {
-        "is_deepfake": is_deepfake,
-        "confidence": round(confidence, 3),
-        "analysis_time": round(analysis_time, 3),
-        "used_model": active_model,
-    }
+    if multi_model_active:
+        models_to_run = settings.AVAILABLE_MODELS.get("text", [])
+        if not models_to_run:
+            raise ValueError("Brak zdefiniowanych modeli tekstowych w ustawieniach systemu.")
+            
+        logger.info(f"Rozpoczęcie wielomodelowej analizy tekstu dla serwera {guild_id} ({len(models_to_run)} modeli)")
+        
+        individual_results = []
+        for m in models_to_run:
+            try:
+                classifier = _load_model(m)
+                result = classifier(text)
+                label = result[0]["label"]
+                score = result[0]["score"]
+                is_fake = label.lower() in ["fake", "ai", "chatgpt", "label_1", "machine-generated"]
+                
+                individual_results.append({
+                    "model": m,
+                    "is_deepfake": is_fake,
+                    "confidence": round(score, 3)
+                })
+            except Exception as e:
+                logger.error(f"Błąd modelu {m} podczas wielomodelowej analizy: {e}")
+        
+        if not individual_results:
+            raise ValueError("Żaden z modeli tekstowych nie dokonał pomyślnej analizy.")
+            
+        # Agregacja: Głosowanie większościowe
+        fake_votes = sum(1 for r in individual_results if r["is_deepfake"])
+        is_deepfake = fake_votes > (len(individual_results) / 2)
+        
+        # Pewność: Średnia pewność wszystkich modeli
+        confidence = sum(r["confidence"] for r in individual_results) / len(individual_results)
+        analysis_time = time.time() - start_time
+        
+        return {
+            "is_deepfake": is_deepfake,
+            "confidence": round(confidence, 3),
+            "analysis_time": round(analysis_time, 3),
+            "used_model": "Multi-Model Workflow (Ensemble)",
+            "details": individual_results  # Przekazujemy szczegóły do bota
+        }
     
-    logger.info(f"Analiza zakończona sukcesem dla serwera {guild_id}.")
-    return response
+    else:
+        # Tradycyjna analiza pojedynczego modelu
+        active_model = get_active_text_model(guild_id)
+        if not active_model:
+            logger.warning(f"Zablokowano zapytanie! Serwer {guild_id} nie ma skonfigurowanego modelu.")
+            raise SetupRequiredError(
+                f"Serwer o ID '{guild_id}' nie został jeszcze skonfigurowany. "
+                "Użyj komendy setup na Discordzie przed wykonaniem analizy."
+            )
+
+        logger.info(f"Rozpoczęcie analizy tekstu dla serwera {guild_id} przy użyciu modelu: {active_model}")
+        
+        classifier = _load_model(active_model)
+        result = classifier(text)
+        
+        label = result[0]["label"]
+        score = result[0]["score"]
+        
+        is_deepfake = label.lower() in ["fake", "ai", "chatgpt", "label_1", "machine-generated"]
+        confidence = score
+        analysis_time = time.time() - start_time
+        
+        return {
+            "is_deepfake": is_deepfake,
+            "confidence": round(confidence, 3),
+            "analysis_time": round(analysis_time, 3),
+            "used_model": active_model,
+            "details": None
+        }

index.js

@@ -82,6 +82,7 @@ async function fetchGuildConfig(guildId) {
 			const data = await response.json();
 			return {
 				logChannelId: data.log_channel_id,
+				multiModelWorkflow: data.multi_model_workflow || false,
 				models: {
 					text: data.active_text_model || "none",
 					image: data.active_image_model || "none"
@@ -93,6 +94,7 @@ async function fetchGuildConfig(guildId) {
 	}
 	return {
 		logChannelId: null,
+		multiModelWorkflow: false,
 		models: {}
 	};
 }
@@ -147,15 +149,19 @@ function generateSetupView(tempConfig, availableModels) {
 		.setTimestamp()
 		.setFooter({ text: "Wybierz opcje i kliknij Zapisz ustawienia" });
 
-	embed.addFields({ 
-		name: "📂 Kanał logów (Raporty)", 
-		value: tempConfig.logChannelId ? `<#${tempConfig.logChannelId}>` : "*Wysyłanie tylko do konsoli*", 
-		inline: false 
+	embed.addFields({
+		name: "🔗 Tryb wielomodelowy (Multi-Model Workflow)",
+		value: tempConfig.multiModelWorkflow 
+			? "🟢 **Włączony** (zostaną użyte wszystkie dostępne modele, indywidualny wybór jest zablokowany)" 
+			: "🔴 **Wyłączony** (będzie używany tylko model wybrany poniżej)",
+		inline: false
 	});
 
-	// Dynamicznie dodajemy pola dla każdego formatu zwróconego przez FastAPI
 	for (const [contentType, models] of Object.entries(availableModels)) {
-		const currentSelected = tempConfig.models[contentType] || models[0] || "Brak";
+		const currentSelected = tempConfig.multiModelWorkflow 
+			? "Wszystkie (Multi-Model Workflow)" 
+			: (tempConfig.models[contentType] || models[0] || "Brak");
+
 		embed.addFields({
 			name: `⚙️ Model dla formatu: ${contentType.toUpperCase()}`,
 			value: `\`${currentSelected}\``,
@@ -172,9 +178,8 @@ function generateSetupView(tempConfig, availableModels) {
 		new ActionRowBuilder().addComponents(channelSelect)
 	];
 
-	// Dynamicznie generujemy menu rozwijane dla każdego formatu danych (tekst, obraz, wideo itp.)
 	for (const [contentType, models] of Object.entries(availableModels)) {
-		if (components.length >= 4) break; // Limit Discorda (max 5 rzędów komponentów na wiadomość)
+		if (components.length >= 4) break;
 
 		const currentSelected = tempConfig.models[contentType] || models[0];
 
@@ -187,12 +192,19 @@ function generateSetupView(tempConfig, availableModels) {
 		const modelSelect = new StringSelectMenuBuilder()
 			.setCustomId(`setup_model_${contentType}`)
 			.setPlaceholder(`Wybierz model dla ${contentType}`)
-			.addOptions(selectOptions);
+			.addOptions(selectOptions)
+			// WYszarzenie i zablokowanie wyboru, gdy włączony jest Multi-Model Workflow
+			.setDisabled(tempConfig.multiModelWorkflow);
 
 		components.push(new ActionRowBuilder().addComponents(modelSelect));
 	}
 
 	const buttonsRow = new ActionRowBuilder().addComponents(
+		new ButtonBuilder()
+			.setCustomId("setup_toggle_multimodel")
+			.setLabel(tempConfig.multiModelWorkflow ? "Tryb Wielomodelowy: WŁ" : "Tryb Wielomodelowy: WYŁ")
+			.setStyle(tempConfig.multiModelWorkflow ? ButtonStyle.Primary : ButtonStyle.Secondary)
+			.setEmoji(tempConfig.multiModelWorkflow ? "🟢" : "⚫"),
 		new ButtonBuilder()
 			.setCustomId("setup_save")
 			.setLabel("Zapisz ustawienia")
@@ -278,22 +290,46 @@ async function handleAnalysis(interaction, userContent, targetMessage = null, ex
 
 		const embedColor = data.is_deepfake ? 0xFF0000 : 0x00FF00;
 		const verdictText = data.is_deepfake ? "⚠️ Wykryto potencjalny Deepfake!" : "✅ Zawartość wydaje się oryginalna";
-		const progressBar = getProgressBar(data.confidence, data.is_deepfake);
 		const confidencePercent = (data.confidence * 100).toFixed(2);
 
 		const embed = new EmbedBuilder()
 			.setColor(embedColor)
 			.setTitle("🛡️ Wynik Analizy Treści")
 			.setDescription(`**Werdykt:** ${verdictText}`)
-			.addFields(
-				{ name: "Pewność modelu", value: `\`${confidencePercent}%\` \n${progressBar}` },
-				{ name: "Czas przetwarzania", value: `\`${data.analysis_time.toFixed(3)}s\``, inline: true },
-				{ name: "Użyty model", value: `\`${data.used_model}\``, inline: true },
-				{ name: "Format danych", value: `\`${data.content_type.toUpperCase()}\``, inline: true }
-			)
 			.setTimestamp()
 			.setFooter({ text: "Deepfake Detection Service", iconURL: client.user.displayAvatarURL() });
 
+		// DYNAMICZNE RENDEROWANIE EMBEDA: Multi-Model vs Single-Model
+		if (data.details && data.details.length > 0) {
+			// Widok dla Multi-Modelu: ładnie listujemy każdy model
+			embed.addFields({ name: "📊 Średnia pewność systemu", value: `\`${confidencePercent}%\``, inline: false });
+			
+			for (const detail of data.details) {
+				const detailBar = getProgressBar(detail.confidence, detail.is_deepfake);
+				const statusText = detail.is_deepfake ? "🟥 FAKE" : "🟩 REAL";
+				const pct = (detail.confidence * 100).toFixed(1);
+				
+				embed.addFields({
+					name: `🤖 Model: ${detail.model.split("/").pop()}`, // skracamy ścieżkę modelu
+					value: `Werdykt: **${statusText}** (Pewność: \`${pct}%\`)\n${detailBar}`,
+					inline: false
+				});
+			}
+		} else {
+			// Standardowy widok dla pojedynczego modelu
+			const progressBar = getProgressBar(data.confidence, data.is_deepfake);
+			embed.addFields(
+				{ name: "Pewność modelu", value: `\`${confidencePercent}%\` \n${progressBar}` },
+				{ name: "Użyty model", value: `\`${data.used_model}\``, inline: true }
+			);
+		}
+
+		// Dodatkowe pola wspólne
+		embed.addFields(
+			{ name: "Czas przetwarzania", value: `\`${data.analysis_time.toFixed(3)}s\``, inline: true },
+			{ name: "Format danych", value: `\`${data.content_type.toUpperCase()}\``, inline: true }
+		);
+
 		const buttonRow = new ActionRowBuilder().addComponents(
 			new ButtonBuilder()
 				.setCustomId("modelCorrect")
@@ -356,6 +392,10 @@ client.on(Events.InteractionCreate, async (interaction) => {
 				});
 			}
 
+			if (currentConfig.multiModelWorkflow === undefined) {
+				currentConfig.multiModelWorkflow = false;
+			}
+
 			for (const [contentType, models] of Object.entries(availableModels)) {
 				if (!currentConfig.models[contentType] && models.length > 0) {
 					currentConfig.models[contentType] = models[0];
@@ -445,7 +485,8 @@ client.on(Events.InteractionCreate, async (interaction) => {
 						body: JSON.stringify({
 							active_text_model: tempSession.config.models?.text || "none",
 							active_image_model: tempSession.config.models?.image || "none",
-							log_channel_id: tempSession.config.logChannelId || null
+							log_channel_id: tempSession.config.logChannelId || null,
+							multi_model_workflow: tempSession.config.multiModelWorkflow || false
 						})
 					});
 
@@ -562,6 +603,14 @@ client.on(Events.InteractionCreate, async (interaction) => {
 				await sendLogToDiscord(interaction.guild, logEmbed);
 			}
 		}
+
+		if (interaction.customId === "setup_toggle_multimodel") {
+			const tempSession = activeSetupSessions.get(guildId);
+			if (tempSession) {
+				tempSession.config.multiModelWorkflow = !tempSession.config.multiModelWorkflow;
+				await interaction.update(generateSetupView(tempSession.config, tempSession.availableModels));
+			}
+		}
 	}
 });