Update app.py

app.py

@@ -38,6 +38,12 @@ async def load_model():
                 trust_remote_code=True
             )
             
+            # Configure padding for processor
+            if hasattr(processor, 'tokenizer'):
+                processor.tokenizer.padding_side = "left"  # Important for Qwen2-VL
+                if processor.tokenizer.pad_token is None:
+                    processor.tokenizer.pad_token = processor.tokenizer.eos_token
+            
             model = Qwen2VLForConditionalGeneration.from_pretrained(
                 model_name,
                 torch_dtype=torch.float32,
@@ -60,6 +66,12 @@ async def load_model():
                     trust_remote_code=True
                 )
                 
+                # Configure padding for processor
+                if hasattr(processor, 'tokenizer'):
+                    processor.tokenizer.padding_side = "left"
+                    if processor.tokenizer.pad_token is None:
+                        processor.tokenizer.pad_token = processor.tokenizer.eos_token
+                
                 model = AutoModel.from_pretrained(
                     model_name,
                     torch_dtype=torch.float32,
@@ -94,6 +106,12 @@ async def load_model():
                     trust_remote_code=True
                 )
                 
+                # Configure padding
+                if hasattr(processor, 'tokenizer'):
+                    processor.tokenizer.padding_side = "left"
+                    if processor.tokenizer.pad_token is None:
+                        processor.tokenizer.pad_token = processor.tokenizer.eos_token
+                
                 model = ModelClass.from_pretrained(
                     model_name,
                     config=config,
@@ -168,6 +186,7 @@ def extract_coordinates(text):
 
 def cpu_inference(conversation, model, tokenizer, processor):
     try:
+        # Apply chat template
         prompt = processor.apply_chat_template(
             conversation, 
             tokenize=False,
@@ -175,14 +194,28 @@ def cpu_inference(conversation, model, tokenizer, processor):
         )
 
         image = conversation[1]["content"][0]["image"]
+        
+        # FIXED: Process inputs dengan padding yang benar
         inputs = processor(
-            text=[prompt],
-            images=[image],
+            text=[prompt],  # Wrap dalam list untuk batch processing
+            images=[image],  # Wrap dalam list untuk batch processing
             return_tensors="pt",
-            padding=True,
+            padding=True,  # Enable padding
             truncation=True,
             max_length=512
         )
+        
+        # FIXED: Pastikan semua tensor memiliki batch dimension yang konsisten
+        for key, value in inputs.items():
+            if isinstance(value, torch.Tensor):
+                logger.debug(f"Input {key} shape: {value.shape}")
+        
+        # FIXED: Set pad_token_id jika belum ada
+        pad_token_id = tokenizer.pad_token_id
+        if pad_token_id is None:
+            pad_token_id = tokenizer.eos_token_id
+        if pad_token_id is None:
+            pad_token_id = 0  # Fallback
 
         with torch.no_grad():
             outputs = model.generate(
@@ -191,21 +224,28 @@ def cpu_inference(conversation, model, tokenizer, processor):
                 do_sample=True,
                 temperature=0.3,
                 top_p=0.8,
-                pad_token_id=tokenizer.eos_token_id or tokenizer.pad_token_id or 0
+                pad_token_id=pad_token_id,
+                attention_mask=inputs.get('attention_mask', None)  # FIXED: Explicit attention mask
             )
 
-        generated_ids = outputs[0][inputs["input_ids"].shape[1]:]
+        # FIXED: Extract generated tokens correctly
+        input_length = inputs["input_ids"].shape[1]
+        generated_ids = outputs[0][input_length:]
         response = tokenizer.decode(generated_ids, skip_special_tokens=True)
         coordinates = extract_coordinates(response)
 
         return {
             "topk_points": coordinates,
-            "response": response,
+            "response": response.strip(),
             "success": True
         }
 
     except Exception as e:
         logger.error(f"Inference error: {e}")
+        # FIXED: More detailed error logging
+        import traceback
+        logger.error(f"Full traceback: {traceback.format_exc()}")
+        
         return {
             "topk_points": [(0.5, 0.5)],
             "response": f"Error during inference: {str(e)}",
@@ -242,9 +282,12 @@ async def predict_click_base64(data: Base64Request):
         
         try:
             pil_image = Image.open(BytesIO(image_data)).convert("RGB")
+            # FIXED: Log image dimensions for debugging
+            logger.debug(f"Image dimensions: {pil_image.size}")
         except Exception as e:
             raise HTTPException(status_code=400, detail=f"Invalid image format: {e}")
 
+        # FIXED: Improved conversation structure
         conversation = [
             {
                 "role": "system",
@@ -272,6 +315,10 @@ async def predict_click_base64(data: Base64Request):
 
         # Run inference
         pred = cpu_inference(conversation, model, tokenizer, processor)
+        
+        if not pred["success"]:
+            logger.warning(f"Inference failed: {pred['response']}")
+        
         px, py = pred["topk_points"][0]
         
         return JSONResponse(content={
@@ -285,6 +332,8 @@ async def predict_click_base64(data: Base64Request):
         raise
     except Exception as e:
         logger.error(f"Prediction error: {e}")
+        import traceback
+        logger.error(f"Full traceback: {traceback.format_exc()}")
         raise HTTPException(
             status_code=500,
             detail=f"Internal server error: {str(e)}"
@@ -306,10 +355,23 @@ async def debug_info():
     import transformers
     available_classes = [attr for attr in dir(transformers) if 'Qwen' in attr or 'VL' in attr]
     
-    return {
+    debug_info = {
         "model_loaded": model_loaded,
         "processor_type": type(processor).__name__ if processor else None,
         "model_type": type(model).__name__ if model else None,
         "available_qwen_classes": available_classes,
         "transformers_version": transformers.__version__
-    }
+    }
+    
+    # FIXED: Add tokenizer info for debugging
+    if processor and hasattr(processor, 'tokenizer'):
+        debug_info.update({
+            "tokenizer_type": type(processor.tokenizer).__name__,
+            "pad_token": processor.tokenizer.pad_token,
+            "pad_token_id": processor.tokenizer.pad_token_id,
+            "eos_token": processor.tokenizer.eos_token,
+            "eos_token_id": processor.tokenizer.eos_token_id,
+            "padding_side": processor.tokenizer.padding_side
+        })
+    
+    return debug_info