Update app.py

app.py

@@ -35,32 +35,33 @@ llm = None
 print("Importing llama_cpp...")
 try:
     from llama_cpp import Llama
-    print("llama_cpp imported successfully")
+    import llama_cpp
+    print(f"llama_cpp version: {llama_cpp.__version__ if hasattr(llama_cpp, '__version__') else 'unknown'}")
 except Exception as e:
     print(f"Error importing llama_cpp: {e}")
     traceback.print_exc()
 
-# Пробуем импортировать chat handlers
+# Пробуем импортировать chat handler для Qwen2-VL
 chat_handler_class = None
+chat_handler_name = None
+
 try:
     from llama_cpp.llama_chat_format import Qwen2VLChatHandler
     chat_handler_class = Qwen2VLChatHandler
-    print("Using Qwen2VLChatHandler")
-except ImportError:
-    print("Qwen2VLChatHandler not found, trying Llava15ChatHandler...")
+    chat_handler_name = "Qwen2VLChatHandler"
+    print(f"✓ Found {chat_handler_name}")
+except ImportError as e:
+    print(f"✗ Qwen2VLChatHandler not found: {e}")
+
+# Список доступных chat handlers
+if chat_handler_class is None:
+    print("\nListing available chat handlers...")
     try:
-        from llama_cpp.llama_chat_format import Llava15ChatHandler
-        chat_handler_class = Llava15ChatHandler
-        print("Using Llava15ChatHandler")
-    except ImportError:
-        print("Llava15ChatHandler not found, trying Llava16ChatHandler...")
-        try:
-            from llama_cpp.llama_chat_format import Llava16ChatHandler
-            chat_handler_class = Llava16ChatHandler
-            print("Using Llava16ChatHandler")
-        except ImportError:
-            print("No suitable chat handler found!")
-            chat_handler_class = None
+        from llama_cpp import llama_chat_format
+        handlers = [name for name in dir(llama_chat_format) if 'Handler' in name or 'Chat' in name]
+        print(f"Available handlers: {handlers}")
+    except Exception as e:
+        print(f"Could not list handlers: {e}")
 
 
 def download_models():
@@ -85,24 +86,25 @@ def download_models():
 
 def load_model():
     """Загрузка модели"""
-    global llm, chat_handler_class
+    global llm, chat_handler_class, chat_handler_name
     
     if llm is not None:
         return True
     
+    if chat_handler_class is None:
+        print("ERROR: No suitable chat handler found for Qwen2-VL!")
+        print("Please ensure llama-cpp-python >= 0.3.2 is installed")
+        return False
+    
     try:
         model_path, mmproj_path = download_models()
         
-        print("Creating chat handler...")
-        if chat_handler_class is not None:
-            chat_handler = chat_handler_class(
-                clip_model_path=mmproj_path,
-                verbose=True
-            )
-            print("Chat handler created")
-        else:
-            print("WARNING: No chat handler, trying without it")
-            chat_handler = None
+        print(f"Creating {chat_handler_name}...")
+        chat_handler = chat_handler_class(
+            clip_model_path=mmproj_path,
+            verbose=True
+        )
+        print("Chat handler created")
         
         print("Loading LLM...")
         llm = Llama(
@@ -178,14 +180,14 @@ def score_single_image(image, use_thinking=True):
         return "❌ Upload an image first", "", ""
     
     if not load_model():
-        return "❌ Failed to load model. Check logs.", "", ""
+        return "❌ Failed to load model. Qwen2VLChatHandler not available. Check logs.", "", ""
     
     template = QUESTION_TEMPLATE_THINKING if use_thinking else QUESTION_TEMPLATE_NO_THINKING
     prompt_text = template.format(Question=PROMPT)
     
-    print("Converting image to data URI...")
+    print("Converting image...")
     image_uri = image_to_data_uri(image)
-    print(f"Image URI created, length: {len(image_uri)}")
+    print(f"Image converted, URI length: {len(image_uri)}")
     
     messages = [
         {
@@ -222,7 +224,7 @@ def score_single_image(image, use_thinking=True):
                 
                 yield generated_text, thinking, score_display
         
-        print(f"Generation complete, output length: {len(generated_text)}")
+        print(f"Generation complete, length: {len(generated_text)}")
         
         final_score = extract_score(generated_text)
         final_thinking = extract_thinking(generated_text) if use_thinking else ""
@@ -230,7 +232,7 @@ def score_single_image(image, use_thinking=True):
         if final_score is not None:
             score_display = f"⭐ **Quality Score: {final_score:.2f} / 5.00**\n\n📊 **For Leaderboard:** `{final_score:.2f}`"
         else:
-            score_display = "❌ Could not extract score. Raw output shown below."
+            score_display = "❌ Could not extract score"
         
         yield generated_text, final_thinking, score_display
         
@@ -245,13 +247,13 @@ def process_batch(files, use_thinking=True, progress=gr.Progress()):
     """Batch processing"""
     global llm
     
-    print(f"process_batch called with {len(files) if files else 0} files")
+    print(f"process_batch: {len(files) if files else 0} files")
     
     if not files:
-        return "❌ No files uploaded", None
+        return "❌ No files", None
     
     if not load_model():
-        return "❌ Failed to load model. Check logs.", None
+        return "❌ Failed to load model", None
     
     results = []
     template = QUESTION_TEMPLATE_THINKING if use_thinking else QUESTION_TEMPLATE_NO_THINKING
@@ -300,7 +302,7 @@ def process_batch(files, use_thinking=True, progress=gr.Progress()):
             })
             
             print(f"  Score: {score}")
-            progress((i + 1) / len(files), desc=f"Processed {i+1}/{len(files)}: {filename}")
+            progress((i + 1) / len(files), desc=f"{i+1}/{len(files)}: {filename}")
             
         except Exception as e:
             print(f"  Error: {e}")
@@ -311,17 +313,16 @@ def process_batch(files, use_thinking=True, progress=gr.Progress()):
                 "raw_output": str(e)
             })
     
-    # Create output files
-    print("Creating output files...")
+    # Create files
     try:
         with tempfile.TemporaryDirectory() as tmpdir:
             txt_file = os.path.join(tmpdir, "leaderboard_scores.txt")
             with open(txt_file, "w") as f:
                 for r in results:
-                    score_str = f"{r['score']:.2f}" if isinstance(r['score'], float) else str(r['score'])
-                    f.write(f"{r['filename']}\t{score_str}\n")
+                    s = f"{r['score']:.2f}" if isinstance(r['score'], float) else str(r['score'])
+                    f.write(f"{r['filename']}\t{s}\n")
             
-            json_file = os.path.join(tmpdir, "full_results.json")
+            json_file = os.path.join(tmpdir, "results.json")
             with open(json_file, "w") as f:
                 json.dump(results, f, indent=2, ensure_ascii=False)
             
@@ -329,122 +330,73 @@ def process_batch(files, use_thinking=True, progress=gr.Progress()):
             with open(csv_file, "w") as f:
                 f.write("filename,score\n")
                 for r in results:
-                    score_str = f"{r['score']:.2f}" if isinstance(r['score'], float) else str(r['score'])
-                    f.write(f"{r['filename']},{score_str}\n")
+                    s = f"{r['score']:.2f}" if isinstance(r['score'], float) else str(r['score'])
+                    f.write(f"{r['filename']},{s}\n")
             
             zip_path = os.path.join(tmpdir, "results.zip")
             with zipfile.ZipFile(zip_path, 'w') as zipf:
                 zipf.write(txt_file, "leaderboard_scores.txt")
-                zipf.write(json_file, "full_results.json")
+                zipf.write(json_file, "results.json")
                 zipf.write(csv_file, "scores.csv")
             
             final_zip = tempfile.NamedTemporaryFile(delete=False, suffix=".zip")
             with open(zip_path, 'rb') as f:
                 final_zip.write(f.read())
             final_zip.close()
-            
-            print(f"Results saved to {final_zip.name}")
     except Exception as e:
-        print(f"Error saving results: {e}")
-        traceback.print_exc()
-        return f"❌ Error saving results: {e}", None
+        return f"❌ Error saving: {e}", None
     
-    # Summary
     valid_scores = [r['score'] for r in results if isinstance(r['score'], float)]
     avg = sum(valid_scores) / len(valid_scores) if valid_scores else 0
     
-    summary = f"""## ✅ Batch Processing Complete!
+    summary = f"""## ✅ Done!
 
-**Processed:** {len(results)} images
-**Successful:** {len(valid_scores)}
-**Failed:** {len(results) - len(valid_scores)}
+**Processed:** {len(results)} | **OK:** {len(valid_scores)} | **Failed:** {len(results) - len(valid_scores)}
 
-### Statistics:
-- **Average Score:** {avg:.2f}
-- **Min Score:** {min(valid_scores):.2f if valid_scores else 'N/A'}
-- **Max Score:** {max(valid_scores):.2f if valid_scores else 'N/A'}
+**Avg:** {avg:.2f} | **Min:** {min(valid_scores):.2f if valid_scores else 'N/A'} | **Max:** {max(valid_scores):.2f if valid_scores else 'N/A'}
 
-### Preview (first 10):
-| Filename | Score |
-|----------|-------|
+| File | Score |
+|------|-------|
 """ + "\n".join([f"| {r['filename'][:40]} | {r['score']:.2f if isinstance(r['score'], float) else r['score']} |" for r in results[:10]])
     
     return summary, final_zip.name
 
 
-# Gradio Interface
-print("Creating Gradio interface...")
+# Interface
+print("Creating interface...")
 
-with gr.Blocks(title="VisualQuality-R1 GGUF") as demo:
+with gr.Blocks(title="VisualQuality-R1") as demo:
     gr.Markdown("""
     # 🎨 VisualQuality-R1 (GGUF/CPU)
     
-    **Image Quality Assessment** | CPU Mode (~30-60 sec per image)
+    **Image Quality Assessment** | ~30-60 sec/image on CPU
     
-    [![Paper](https://img.shields.io/badge/arXiv-Paper-red)](https://arxiv.org/abs/2505.14460)
-    [![Model](https://img.shields.io/badge/🤗-Model-yellow)](https://huggingface.co/TianheWu/VisualQuality-R1-7B)
+    [![Paper](https://img.shields.io/badge/arXiv-2505.14460-red)](https://arxiv.org/abs/2505.14460)
     """)
     
     with gr.Tabs():
-        with gr.TabItem("📷 Single Image"):
+        with gr.TabItem("📷 Single"):
             with gr.Row():
                 with gr.Column():
-                    img_input = gr.Image(label="📷 Upload Image", type="pil", height=350)
-                    thinking_cb = gr.Checkbox(label="🧠 Enable Thinking Mode", value=True)
-                    analyze_btn = gr.Button("🔍 Analyze Quality", variant="primary", size="lg")
-                
+                    img = gr.Image(label="Image", type="pil", height=350)
+                    think = gr.Checkbox(label="🧠 Thinking", value=True)
+                    btn = gr.Button("🔍 Analyze", variant="primary", size="lg")
                 with gr.Column():
-                    score_out = gr.Markdown(value="*Upload an image to see the score*")
-                    thinking_out = gr.Textbox(label="🧠 Thinking Process", lines=6, interactive=False)
-                    raw_out = gr.Textbox(label="📝 Full Output", lines=8, interactive=False)
-            
-            analyze_btn.click(
-                score_single_image,
-                inputs=[img_input, thinking_cb],
-                outputs=[raw_out, thinking_out, score_out]
-            )
+                    score = gr.Markdown("*Upload image*")
+                    thinking = gr.Textbox(label="Thinking", lines=6)
+                    output = gr.Textbox(label="Output", lines=8)
+            btn.click(score_single_image, [img, think], [output, thinking, score])
         
-        with gr.TabItem("📁 Batch Processing"):
-            gr.Markdown("""
-            ### Batch Processing for Leaderboard
-            Upload multiple images. Results in TXT, CSV, JSON formats.
-            
-            ⚠️ ~30-60 seconds per image on CPU
-            """)
-            
+        with gr.TabItem("📁 Batch"):
             with gr.Row():
                 with gr.Column():
-                    batch_files = gr.File(
-                        label="📁 Upload Images",
-                        file_count="multiple",
-                        file_types=["image"]
-                    )
-                    batch_thinking = gr.Checkbox(
-                        label="🧠 Enable Thinking (slower)",
-                        value=False
-                    )
-                    batch_btn = gr.Button("🚀 Process All", variant="primary", size="lg")
-                
+                    files = gr.File(label="Images", file_count="multiple", file_types=["image"])
+                    batch_think = gr.Checkbox(label="🧠 Thinking", value=False)
+                    batch_btn = gr.Button("🚀 Process", variant="primary", size="lg")
                 with gr.Column():
-                    batch_summary = gr.Markdown(value="*Upload images and click Process*")
-                    batch_download = gr.File(label="📥 Download Results (ZIP)")
-            
-            batch_btn.click(
-                process_batch,
-                inputs=[batch_files, batch_thinking],
-                outputs=[batch_summary, batch_download]
-            )
-    
-    gr.Markdown("""
-    ---
-    | Score | Quality |
-    |-------|---------|
-    | 1.0 | Very poor |
-    | 2.0 | Poor |
-    | 3.0 | Fair |
-    | 4.0 | Good |
-    | 5.0 | Excellent |
-    """)
+                    summary = gr.Markdown("*Upload & Process*")
+                    download = gr.File(label="📥 Results")
+            batch_btn.click(process_batch, [files, batch_think], [summary, download])
 
 print("Starting server...")