Update app.py

app.py

@@ -132,18 +132,35 @@ def generate_summary(chunks: List[Document], length_type="sentences", length_cou
         length_type: Either "sentences" or "paragraphs"
         length_count: Number of sentences (1-10) or paragraphs (1-3)
     """
+    # Print debug information to track what parameters are being used
+    print(f"Generating summary with length_type={length_type}, length_count={length_count}")
+    
+    # Ensure length_count is an integer
+    try:
+        length_count = int(length_count)
+    except (ValueError, TypeError):
+        # Default to 3 if conversion fails
+        print(f"Failed to convert length_count to int: {length_count}, using default 3")
+        length_count = 3
+    
+    # Apply limits based on type
+    if length_type == "sentences":
+        length_count = max(1, min(10, length_count))  # Limit to 1-10 sentences
+    else:  # paragraphs
+        length_count = max(1, min(3, length_count))   # Limit to 1-3 paragraphs
+    
     # Concatenate the retrieved chunks
     combined_text = " ".join([chunk.page_content for chunk in chunks])
     
-    # Construct length instruction based on type and count
+    # Use a more direct instruction to enforce the length constraint
     if length_type == "sentences":
-        length_instruction = f"Summarize the following text in {length_count} sentence{'s' if length_count > 1 else ''}."
+        length_instruction = f"Your summary must be EXACTLY {length_count} sentence{'s' if length_count > 1 else ''}. Not more, not less."
     else:  # paragraphs
-        length_instruction = f"Summarize the following text in {length_count} paragraph{'s' if length_count > 1 else ''}."
+        length_instruction = f"Your summary must be EXACTLY {length_count} paragraph{'s' if length_count > 1 else ''}. Not more, not less."
     
-    # Construct the prompt
+    # Construct the prompt with clearer instructions
     prompt = f"""<instruction>
-Knowledge Cutoff Date: April 2024. You are Granite, developed by IBM. You are a helpful AI assistant. {length_instruction} Your response should only include the answer. Do not provide any further explanation.
+Knowledge Cutoff Date: April 2024. You are Granite, developed by IBM. You are a helpful AI assistant. Summarize the following text. {length_instruction} Your response should only include the summary. Do not provide any further explanation.
 </instruction>
 
 <text>
@@ -154,16 +171,18 @@ Knowledge Cutoff Date: April 2024. You are Granite, developed by IBM. You are a
     # Calculate appropriate max_new_tokens based on length requirements
     # Approximate tokens: ~15 tokens per sentence, ~75 tokens per paragraph
     if length_type == "sentences":
-        max_tokens = length_count * 20  # Slightly more than needed for flexibility
+        max_tokens = length_count * 30  # Increased slightly for flexibility
     else:  # paragraphs
-        max_tokens = length_count * 100  # Slightly more than needed for flexibility
+        max_tokens = length_count * 120  # Increased slightly for flexibility
     
     # Ensure minimum tokens and add buffer
-    max_tokens = max(100, min(1000, max_tokens + 50))
+    max_tokens = max(100, min(1500, max_tokens + 50))
     
     # Generate the summary using the IBM Granite model
     inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
     
+    print(f"Using max_new_tokens={max_tokens}")
+    
     with torch.no_grad():
         output = model.generate(
             **inputs,
@@ -385,14 +404,35 @@ def create_gradio_interface():
             # Convert capitalized length_type to lowercase for processing
             length_type_lower = length_type.lower()
             
+            print(f"Processing with length_type={length_type}, sentence_count={sentence_count}, paragraph_count={paragraph_count}")
+            
+            # Determine count based on the selected length type
             if length_type_lower == "sentences":
-                count = int(sentence_count)
+                # For sentences, use the slider value directly
+                try:
+                    count = int(sentence_count)
+                    count = max(1, min(10, count))  # Ensure within range 1-10
+                    print(f"Using sentence count: {count}")
+                except (ValueError, TypeError):
+                    print(f"Invalid sentence count: {sentence_count}, using default 3")
+                    count = 3
             else:
-                # Handle potential type issues with paragraph_count
-                if isinstance(paragraph_count, bool):
-                    count = 1  # Default if boolean
-                else:
-                    count = int(paragraph_count)
+                # For paragraphs, convert from string to int if needed
+                try:
+                    # Check if paragraph_count is a string (from radio button)
+                    if isinstance(paragraph_count, str):
+                        count = int(paragraph_count)
+                    # Check if it's a boolean (from visibility toggle)
+                    elif isinstance(paragraph_count, bool):
+                        count = 1  # Default if boolean
+                    else:
+                        count = int(paragraph_count)
+                    
+                    count = max(1, min(3, count))  # Ensure within range 1-3
+                    print(f"Using paragraph count: {count}")
+                except (ValueError, TypeError):
+                    print(f"Invalid paragraph count: {paragraph_count}, using default 1")
+                    count = 1
             
             return process_document(file, length_type_lower, count)