Update app.py

app.py

@@ -1,11 +1,10 @@
 import gradio as gr
-from PIL import Image, PngImagePlugin
+from PIL import Image, PngImagePlugin # Убедимся, что Image из PIL импортирован
 import io
 import os
 import pandas as pd
 import torch
-# from transformers import pipeline as transformers_pipeline , AutoModelForImageClassification, CLIPImageProcessor # ImageReward пока отключен
-from transformers import pipeline as transformers_pipeline , CLIPImageProcessor # Убрали AutoModelForImageClassification
+from transformers import pipeline as transformers_pipeline , CLIPImageProcessor
 import open_clip
 import re
 import matplotlib.pyplot as plt
@@ -14,6 +13,7 @@ from collections import defaultdict
 import numpy as np
 import logging
 import time
+import tempfile 
 
 # --- ONNX Related Imports and Setup ---
 try:
@@ -84,49 +84,25 @@ def get_onnx_session_and_meta(repo_id, model_subfolder, current_log_list):
         onnx_sessions_cache[cache_key] = (None, [], None)
         return None, [], None
 
-# 1. ImageReward - ВРЕМЕННО ОТКЛЮЧЕНО
 reward_processor, reward_model = None, None
 print("INFO: THUDM/ImageReward is temporarily disabled due to loading issues.")
-# try:
-#     print("INFO: Loading THUDM/ImageReward model...")
-#     # reward_processor = CLIPImageProcessor.from_pretrained("openai/clip-vit-large-patch14")
-#     # reward_model = AutoModelForImageClassification.from_pretrained("THUDM/ImageReward", trust_remote_code=True).to(DEVICE) # Попытка с trust_remote_code
-#     # reward_model.eval()
-#     # print("INFO: THUDM/ImageReward loaded successfully.")
-# except Exception as e:
-#     print(f"ERROR: Failed to load THUDM/ImageReward: {e}")
-
-
-ANIME_AESTHETIC_REPO = "deepghs/anime_aesthetic"
-ANIME_AESTHETIC_SUBFOLDER = "swinv2pv3_v0_448_ls0.2_x"
-ANIME_AESTHETIC_IMG_SIZE = (448, 448)
-ANIME_AESTHETIC_LABEL_WEIGHTS = {"normal": 0.0, "slight": 1.0, "moderate": 2.0, "strong": 3.0, "extreme": 4.0}
+ANIME_AESTHETIC_REPO = "deepghs/anime_aesthetic"; ANIME_AESTHETIC_SUBFOLDER = "swinv2pv3_v0_448_ls0.2_x"
+ANIME_AESTHETIC_IMG_SIZE = (448, 448); ANIME_AESTHETIC_LABEL_WEIGHTS = {"normal": 0.0, "slight": 1.0, "moderate": 2.0, "strong": 3.0, "extreme": 4.0}
 print("INFO: MANIQA (honklers/maniqa-nr) is currently disabled.")
-
 clip_model_instance, clip_preprocess, clip_tokenizer = None, None, None
 try:
-    clip_model_name = 'ViT-L-14'
-    print(f"INFO: Loading CLIP model {clip_model_name} (laion2b_s32b_b82k)...")
-    clip_model_instance, _, clip_preprocess_val = open_clip.create_model_and_transforms(
-        clip_model_name, pretrained='laion2b_s32b_b82k', device=DEVICE
-    )
-    clip_preprocess = clip_preprocess_val
-    clip_tokenizer = open_clip.get_tokenizer(clip_model_name)
-    clip_model_instance.eval()
-    print(f"INFO: CLIP model {clip_model_name} (laion2b_s32b_b82k) loaded successfully.")
-except Exception as e:
-    print(f"ERROR: Failed to load CLIP model {clip_model_name} (laion2b_s32b_b82k): {e}")
-
+    clip_model_name = 'ViT-L-14'; print(f"INFO: Loading CLIP model {clip_model_name} (laion2b_s32b_b82k)...")
+    clip_model_instance, _, clip_preprocess_val = open_clip.create_model_and_transforms(clip_model_name, pretrained='laion2b_s32b_b82k', device=DEVICE)
+    clip_preprocess = clip_preprocess_val; clip_tokenizer = open_clip.get_tokenizer(clip_model_name)
+    clip_model_instance.eval(); print(f"INFO: CLIP model {clip_model_name} (laion2b_s32b_b82k) loaded successfully.")
+except Exception as e: print(f"ERROR: Failed to load CLIP model {clip_model_name} (laion2b_s32b_b82k): {e}")
 sdxl_detector_pipe = None
 try:
     print("INFO: Loading Organika/sdxl-detector model...")
     sdxl_detector_pipe = transformers_pipeline("image-classification", model="Organika/sdxl-detector", device=torch.device(DEVICE).index if DEVICE=="cuda" else -1)
     print("INFO: Organika/sdxl-detector loaded successfully.")
-except Exception as e:
-    print(f"ERROR: Failed to load Organika/sdxl-detector: {e}")
-
-ANIME_AI_CHECK_REPO = "deepghs/anime_ai_check"
-ANIME_AI_CHECK_SUBFOLDER = "caformer_s36_plus_sce"
+except Exception as e: print(f"ERROR: Failed to load Organika/sdxl-detector: {e}")
+ANIME_AI_CHECK_REPO = "deepghs/anime_ai_check"; ANIME_AI_CHECK_SUBFOLDER = "caformer_s36_plus_sce"
 ANIME_AI_CHECK_IMG_SIZE = (384, 384)
 
 def extract_sd_parameters(image_pil, filename_for_log, current_log_list):
@@ -152,8 +128,7 @@ def extract_sd_parameters(image_pil, filename_for_log, current_log_list):
                 negative_prompt = parameters_str[neg_prompt_index + len("Negative prompt:"):end_of_neg].strip()
                 params_part = parameters_str[end_of_neg:].strip() if end_of_neg < len(parameters_str) else ""
         elif steps_meta_index != -1:
-            prompt = parameters_str[:steps_meta_index].strip()
-            params_part = parameters_str[steps_meta_index:]
+            prompt = parameters_str[:steps_meta_index].strip(); params_part = parameters_str[steps_meta_index:]
         else:
             prompt = parameters_str.strip(); params_part = ""
         if params_part:
@@ -172,35 +147,14 @@ def extract_sd_parameters(image_pil, filename_for_log, current_log_list):
         if model_name == "N/A" and "Checkpoint" in other_params_dict: model_name = other_params_dict["Checkpoint"]
         if model_name == "N/A" and "model" in other_params_dict: model_name = other_params_dict["model"]
         current_log_list.append(f"DEBUG [{filename_for_log}]: Parsed Prompt: {prompt[:50]}... | Model: {model_name}")
-    except Exception as e:
-        current_log_list.append(f"ERROR [{filename_for_log}]: Failed to parse metadata: {e}")
+    except Exception as e: current_log_list.append(f"ERROR [{filename_for_log}]: Failed to parse metadata: {e}")
     return prompt, negative_prompt, model_name, model_hash, other_params_dict
 
 @torch.no_grad()
-def get_image_reward(image_pil, filename_for_log, current_log_list):
-    # current_log_list.append(f"INFO [{filename_for_log}]: ImageReward model not loaded (disabled), skipping.")
-    return "N/A (Disabled)" # Временно отключено
-    # if not reward_model or not reward_processor:
-    #     current_log_list.append(f"INFO [{filename_for_log}]: ImageReward model not loaded, skipping.")
-    #     return "N/A"
-    # t_start = time.time()
-    # current_log_list.append(f"DEBUG [{filename_for_log}]: Starting ImageReward score (PyTorch Device: {DEVICE})...")
-    # try:
-    #     inputs = reward_processor(images=image_pil, return_tensors="pt", padding=True, truncation=True).to(DEVICE)
-    #     outputs = reward_model(**inputs)
-    #     score = round(outputs.logits.item(), 4)
-    #     t_end = time.time()
-    #     current_log_list.append(f"DEBUG [{filename_for_log}]: ImageReward score: {score} (took {t_end - t_start:.2f}s)")
-    #     return score
-    # except Exception as e:
-    #     current_log_list.append(f"ERROR [{filename_for_log}]: ImageReward scoring failed: {e}")
-    #     return "Error"
-
+def get_image_reward(image_pil, filename_for_log, current_log_list): return "N/A (Disabled)"
 def get_anime_aesthetic_score_deepghs(image_pil, filename_for_log, current_log_list):
     session, labels, meta = get_onnx_session_and_meta(ANIME_AESTHETIC_REPO, ANIME_AESTHETIC_SUBFOLDER, current_log_list)
-    if not session or not labels:
-        current_log_list.append(f"INFO [{filename_for_log}]: AnimeAesthetic ONNX model not loaded, skipping.")
-        return "N/A"
+    if not session or not labels: current_log_list.append(f"INFO [{filename_for_log}]: AnimeAesthetic ONNX model not loaded, skipping."); return "N/A"
     t_start = time.time(); current_log_list.append(f"DEBUG [{filename_for_log}]: Starting AnimeAesthetic (ONNX) score...")
     try:
         input_data = _img_preprocess_for_onnx(image_pil.copy(), size=ANIME_AESTHETIC_IMG_SIZE)
@@ -209,24 +163,15 @@ def get_anime_aesthetic_score_deepghs(image_pil, filename_for_log, current_log_l
         scores = onnx_output[0]; exp_scores = np.exp(scores - np.max(scores)); probabilities = exp_scores / np.sum(exp_scores)
         weighted_score = sum(probabilities[i] * ANIME_AESTHETIC_LABEL_WEIGHTS.get(label, 0.0) for i, label in enumerate(labels))
         score = round(weighted_score, 4); t_end = time.time()
-        current_log_list.append(f"DEBUG [{filename_for_log}]: AnimeAesthetic (ONNX) score: {score} (took {t_end - t_start:.2f}s)")
-        return score
-    except Exception as e:
-        current_log_list.append(f"ERROR [{filename_for_log}]: AnimeAesthetic (ONNX) scoring failed: {e}"); return "Error"
-
+        current_log_list.append(f"DEBUG [{filename_for_log}]: AnimeAesthetic (ONNX) score: {score} (took {t_end - t_start:.2f}s)"); return score
+    except Exception as e: current_log_list.append(f"ERROR [{filename_for_log}]: AnimeAesthetic (ONNX) scoring failed: {e}"); return "Error"
 @torch.no_grad()
 def get_maniqa_score(image_pil, filename_for_log, current_log_list):
-    current_log_list.append(f"INFO [{filename_for_log}]: MANIQA is disabled.")
-    return "N/A (Disabled)"
-
+    current_log_list.append(f"INFO [{filename_for_log}]: MANIQA is disabled."); return "N/A (Disabled)"
 @torch.no_grad()
 def calculate_clip_score_value(image_pil, prompt_text, filename_for_log, current_log_list):
-    if not clip_model_instance or not clip_preprocess or not clip_tokenizer:
-        current_log_list.append(f"INFO [{filename_for_log}]: CLIP model not loaded, skipping CLIPScore.")
-        return "N/A"
-    if not prompt_text or prompt_text == "N/A":
-        current_log_list.append(f"INFO [{filename_for_log}]: Empty prompt, skipping CLIPScore.")
-        return "N/A (Empty Prompt)"
+    if not clip_model_instance or not clip_preprocess or not clip_tokenizer: current_log_list.append(f"INFO [{filename_for_log}]: CLIP model not loaded, skipping CLIPScore."); return "N/A"
+    if not prompt_text or prompt_text == "N/A": current_log_list.append(f"INFO [{filename_for_log}]: Empty prompt, skipping CLIPScore."); return "N/A (Empty Prompt)"
     t_start = time.time(); current_log_list.append(f"DEBUG [{filename_for_log}]: Starting CLIPScore (PyTorch Device: {DEVICE})...")
     try:
         image_input = clip_preprocess(image_pil).unsqueeze(0).to(DEVICE)
@@ -236,32 +181,22 @@ def calculate_clip_score_value(image_pil, prompt_text, filename_for_log, current
         text_features_norm = text_features / text_features.norm(p=2, dim=-1, keepdim=True)
         score_val = (text_features_norm @ image_features_norm.T).squeeze().item() * 100.0
         score = round(score_val, 2); t_end = time.time()
-        current_log_list.append(f"DEBUG [{filename_for_log}]: CLIPScore: {score} (took {t_end - t_start:.2f}s)")
-        return score
-    except Exception as e:
-        current_log_list.append(f"ERROR [{filename_for_log}]: CLIPScore calculation failed: {e}"); return "Error"
-
+        current_log_list.append(f"DEBUG [{filename_for_log}]: CLIPScore: {score} (took {t_end - t_start:.2f}s)"); return score
+    except Exception as e: current_log_list.append(f"ERROR [{filename_for_log}]: CLIPScore calculation failed: {e}"); return "Error"
 @torch.no_grad()
 def get_sdxl_detection_score(image_pil, filename_for_log, current_log_list):
-    if not sdxl_detector_pipe:
-        current_log_list.append(f"INFO [{filename_for_log}]: SDXL_Detector model not loaded, skipping.")
-        return "N/A"
+    if not sdxl_detector_pipe: current_log_list.append(f"INFO [{filename_for_log}]: SDXL_Detector model not loaded, skipping."); return "N/A"
     t_start = time.time(); current_log_list.append(f"DEBUG [{filename_for_log}]: Starting SDXL_Detector score (Device: {sdxl_detector_pipe.device})...")
     try:
         result = sdxl_detector_pipe(image_pil.copy()); ai_score_val = 0.0
         for item in result:
             if item['label'].lower() == 'artificial': ai_score_val = item['score']; break
         score = round(ai_score_val, 4); t_end = time.time()
-        current_log_list.append(f"DEBUG [{filename_for_log}]: SDXL_Detector AI Prob: {score} (took {t_end - t_start:.2f}s)")
-        return score
-    except Exception as e:
-        current_log_list.append(f"ERROR [{filename_for_log}]: SDXL_Detector scoring failed: {e}"); return "Error"
-
+        current_log_list.append(f"DEBUG [{filename_for_log}]: SDXL_Detector AI Prob: {score} (took {t_end - t_start:.2f}s)"); return score
+    except Exception as e: current_log_list.append(f"ERROR [{filename_for_log}]: SDXL_Detector scoring failed: {e}"); return "Error"
 def get_anime_ai_check_score_deepghs(image_pil, filename_for_log, current_log_list):
     session, labels, meta = get_onnx_session_and_meta(ANIME_AI_CHECK_REPO, ANIME_AI_CHECK_SUBFOLDER, current_log_list)
-    if not session or not labels:
-        current_log_list.append(f"INFO [{filename_for_log}]: AnimeAI_Check ONNX model not loaded, skipping.")
-        return "N/A"
+    if not session or not labels: current_log_list.append(f"INFO [{filename_for_log}]: AnimeAI_Check ONNX model not loaded, skipping."); return "N/A"
     t_start = time.time(); current_log_list.append(f"DEBUG [{filename_for_log}]: Starting AnimeAI_Check (ONNX) score...")
     try:
         input_data = _img_preprocess_for_onnx(image_pil.copy(), size=ANIME_AI_CHECK_IMG_SIZE)
@@ -272,43 +207,38 @@ def get_anime_ai_check_score_deepghs(image_pil, filename_for_log, current_log_li
         for i, label in enumerate(labels):
             if label.lower() == 'ai': ai_prob_val = probabilities[i]; break
         score = round(ai_prob_val, 4); t_end = time.time()
-        current_log_list.append(f"DEBUG [{filename_for_log}]: AnimeAI_Check (ONNX) AI Prob: {score} (took {t_end - t_start:.2f}s)")
-        return score
-    except Exception as e:
-        current_log_list.append(f"ERROR [{filename_for_log}]: AnimeAI_Check (ONNX) scoring failed: {e}"); return "Error"
+        current_log_list.append(f"DEBUG [{filename_for_log}]: AnimeAI_Check (ONNX) AI Prob: {score} (took {t_end - t_start:.2f}s)"); return score
+    except Exception as e: current_log_list.append(f"ERROR [{filename_for_log}]: AnimeAI_Check (ONNX) scoring failed: {e}"); return "Error"
 
 def process_images_generator(files, progress=gr.Progress(track_tqdm=True)):
     if not files:
-        yield pd.DataFrame(), None, None, None, None, "Please upload some images.", "No files to process."
+        yield (pd.DataFrame(), 
+               gr.Image(visible=False), gr.Image(visible=False), 
+               gr.File(visible=False), gr.File(visible=False), 
+               "Please upload some images.", "No files to process.")
         return
 
     all_results = []
     log_accumulator = [f"INFO: Starting processing for {len(files)} images..."]
-    # Начальный yield для лога и статуса
-    yield (pd.DataFrame(all_results), None, None, 
-           gr.File(visible=False), gr.File(visible=False), # Скрываем кнопки скачивания вначале
+    yield (pd.DataFrame(all_results), 
+           gr.Image(visible=False), gr.Image(visible=False), 
+           gr.File(visible=False), gr.File(visible=False), 
            "Processing...", "\n".join(log_accumulator))
 
     for i, file_obj in enumerate(files):
-        filename_for_log = "Unknown File"
-        current_img_total_time_start = time.time()
+        filename_for_log = "Unknown File"; current_img_total_time_start = time.time()
         try:
             filename_for_log = os.path.basename(getattr(file_obj, 'name', f"file_{i}_{int(time.time())}"))
             log_accumulator.append(f"--- Processing image {i+1}/{len(files)}: {filename_for_log} ---")
-            
-            # Используем progress(float, desc=...)
             progress( (i + 0.1) / len(files), desc=f"Img {i+1}/{len(files)}: Loading {filename_for_log}")
-            # Немедленно обновляем UI с логом перед тяжелой загрузкой изображения
-            yield (pd.DataFrame(all_results), None, None, 
+            yield (pd.DataFrame(all_results), 
+                   gr.Image(visible=False), gr.Image(visible=False), 
                    gr.File(visible=False), gr.File(visible=False),
-                   f"Loading image {i+1}/{len(files)}: {filename_for_log}", 
-                   "\n".join(log_accumulator))
+                   f"Loading image {i+1}/{len(files)}: {filename_for_log}", "\n".join(log_accumulator))
 
             img = Image.open(getattr(file_obj, 'name', str(file_obj)))
             if img.mode != "RGB": img = img.convert("RGB")
             progress( (i + 0.3) / len(files), desc=f"Img {i+1}/{len(files)}: Scoring {filename_for_log}")
-
-
             prompt, neg_prompt, model_n, model_h, other_p = extract_sd_parameters(img, filename_for_log, log_accumulator)
             reward = get_image_reward(img, filename_for_log, log_accumulator)
             anime_aes_deepghs = get_anime_aesthetic_score_deepghs(img, filename_for_log, log_accumulator)
@@ -318,7 +248,6 @@ def process_images_generator(files, progress=gr.Progress(track_tqdm=True)):
             anime_ai_chk_deepghs = get_anime_ai_check_score_deepghs(img, filename_for_log, log_accumulator)
             current_img_total_time_end = time.time()
             log_accumulator.append(f"INFO [{filename_for_log}]: Finished all scores (total for image: {current_img_total_time_end - current_img_total_time_start:.2f}s)")
-
             all_results.append({
                 "Filename": filename_for_log, "Prompt": prompt if prompt else "N/A", "Model Name": model_n, "Model Hash": model_h,
                 "ImageReward": reward, "AnimeAesthetic_dg": anime_aes_deepghs, "MANIQA_TQ": maniqa,
@@ -326,10 +255,10 @@ def process_images_generator(files, progress=gr.Progress(track_tqdm=True)):
             })
             df_so_far = pd.DataFrame(all_results)
             progress( (i + 1.0) / len(files), desc=f"Img {i+1}/{len(files)}: Done {filename_for_log}")
-            yield (df_so_far, None, None, 
+            yield (df_so_far, 
+                   gr.Image(visible=False), gr.Image(visible=False), 
                    gr.File(visible=False), gr.File(visible=False),
-                   f"Processed image {i+1}/{len(files)}: {filename_for_log}", 
-                   "\n".join(log_accumulator))
+                   f"Processed image {i+1}/{len(files)}: {filename_for_log}", "\n".join(log_accumulator))
         except Exception as e:
             log_accumulator.append(f"CRITICAL ERROR processing {filename_for_log}: {e}")
             print(f"CRITICAL ERROR processing {filename_for_log}: {e}")
@@ -339,21 +268,21 @@ def process_images_generator(files, progress=gr.Progress(track_tqdm=True)):
                 "CLIPScore": "Error", "SDXL_Detector_AI_Prob": "Error", "AnimeAI_Check_dg_Prob": "Error"
             })
             df_so_far = pd.DataFrame(all_results)
-            yield (df_so_far, None, None, 
+            yield (df_so_far, 
+                   gr.Image(visible=False), gr.Image(visible=False), 
                    gr.File(visible=False), gr.File(visible=False),
-                   f"Error on image {i+1}/{len(files)}: {filename_for_log}",
-                   "\n".join(log_accumulator))
+                   f"Error on image {i+1}/{len(files)}: {filename_for_log}", "\n".join(log_accumulator))
 
     log_accumulator.append("--- Generating final plots and download files ---")
     progress(1.0, desc="Generating final plots...")
-    yield (pd.DataFrame(all_results), None, None, 
+    yield (pd.DataFrame(all_results), 
+           gr.Image(visible=False), gr.Image(visible=False), 
            gr.File(visible=False), gr.File(visible=False),
-           "Generating final plots...",
-           "\n".join(log_accumulator))
+           "Generating final plots...", "\n".join(log_accumulator))
 
     df = pd.DataFrame(all_results)
     plot_model_avg_scores_buffer, plot_prompt_clip_scores_buffer = None, None
-    csv_file_path_out, json_file_path_out = None, None # Будем возвращать пути к файлам
+    csv_file_path_out, json_file_path_out = None, None
 
     if not df.empty:
         numeric_cols = ["ImageReward", "AnimeAesthetic_dg", "MANIQA_TQ", "CLIPScore"]
@@ -381,35 +310,36 @@ def process_images_generator(files, progress=gr.Progress(track_tqdm=True)):
                     plt.tight_layout(); plot_prompt_clip_scores_buffer = io.BytesIO(); fig2.savefig(plot_prompt_clip_scores_buffer, format="png"); plot_prompt_clip_scores_buffer.seek(0); plt.close(fig2)
                     log_accumulator.append("INFO: Prompt CLIP scores plot generated.")
             except Exception as e: log_accumulator.append(f"ERROR: Failed to generate prompt CLIP scores plot: {e}")
-        
-        # Сохраняем файлы во временные файлы и возвращаем пути
         try:
             with tempfile.NamedTemporaryFile(mode="w+", delete=False, suffix=".csv", encoding='utf-8') as tmp_csv:
-                df.to_csv(tmp_csv, index=False)
-                csv_file_path_out = tmp_csv.name
+                df.to_csv(tmp_csv, index=False); csv_file_path_out = tmp_csv.name
             with tempfile.NamedTemporaryFile(mode="w+", delete=False, suffix=".json", encoding='utf-8') as tmp_json:
-                df.to_json(tmp_json, orient='records', indent=4)
-                json_file_path_out = tmp_json.name
+                df.to_json(tmp_json, orient='records', indent=4); json_file_path_out = tmp_json.name
             log_accumulator.append("INFO: CSV and JSON data prepared for download.")
-        except Exception as e:
-            log_accumulator.append(f"ERROR preparing download files: {e}")
-
+        except Exception as e: log_accumulator.append(f"ERROR preparing download files: {e}")
 
     final_status = f"Finished processing {len(all_results)} images."
     log_accumulator.append(final_status)
     
+    # Преобразуем BytesIO в PIL.Image перед передачей в gr.Image
+    pil_plot_model_avg = Image.open(plot_model_avg_scores_buffer) if plot_model_avg_scores_buffer and plot_model_avg_scores_buffer.getbuffer().nbytes > 0 else None
+    pil_plot_prompt_clip = Image.open(plot_prompt_clip_scores_buffer) if plot_prompt_clip_scores_buffer and plot_prompt_clip_scores_buffer.getbuffer().nbytes > 0 else None
+    if pil_plot_model_avg or pil_plot_prompt_clip:
+        log_accumulator.append("INFO: Plots converted to PIL Images for display.")
+    else:
+        log_accumulator.append("INFO: No plots were generated or plots are empty.")
+
+
     yield (
         df,
-        gr.Image(value=plot_model_avg_scores_buffer, visible=plot_model_avg_scores_buffer is not None),
-        gr.Image(value=plot_prompt_clip_scores_buffer, visible=plot_prompt_clip_scores_buffer is not None),
-        gr.File(value=csv_file_path_out, visible=csv_file_path_out is not None), # Убрали file_name
-        gr.File(value=json_file_path_out, visible=json_file_path_out is not None), # Убрали file_name
+        gr.Image(value=pil_plot_model_avg, visible=pil_plot_model_avg is not None), 
+        gr.Image(value=pil_plot_prompt_clip, visible=pil_plot_prompt_clip is not None),
+        gr.File(value=csv_file_path_out, visible=csv_file_path_out is not None),
+        gr.File(value=json_file_path_out, visible=json_file_path_out is not None),
         final_status,
         "\n".join(log_accumulator)
     )
 
-import tempfile # Для gr.File
-
 with gr.Blocks(css="footer {display: none !important}") as demo:
     gr.Markdown("# AI Image Model Evaluation Tool")
     gr.Markdown("Upload PNG images (ideally with Stable Diffusion metadata) to evaluate them...")
@@ -423,8 +353,8 @@ with gr.Blocks(css="footer {display: none !important}") as demo:
         "MANIQA_TQ", "CLIPScore", "SDXL_Detector_AI_Prob", "AnimeAI_Check_dg_Prob"
     ], wrap=True)
     with gr.Row():
-        download_csv_button = gr.File(label="Download CSV Results", interactive=False) # Будет обновляться из yield
-        download_json_button = gr.File(label="Download JSON Results", interactive=False) # Будет обновляться из yield
+        download_csv_button = gr.File(label="Download CSV Results", interactive=False)
+        download_json_button = gr.File(label="Download JSON Results", interactive=False)
     gr.Markdown("## Visualizations")
     with gr.Row():
         plot_output_model_avg = gr.Image(label="Average Scores per Model", type="pil", interactive=False)