more

app.py

@@ -16,72 +16,107 @@ FastLanguageModel.for_inference(model)  # Enable optimized inference
 
 # Define the response function
 def respond(message, history, system_message, max_tokens, temperature, top_p):
-    # Print the inputs at the start
-    print("===== Respond Function Called =====")
-    print(f"Received message: {message}")
-    print(f"Current history: {history}")
+    # Extensive debugging print statements
+    print("\n" + "="*50)
+    print("===== RESPOND FUNCTION CALLED =====")
+    print("="*50)
+    
+    # Print input parameters
+    print(f"Input Message: {message}")
+    print(f"System Message: {system_message}")
+    print(f"Max Tokens: {max_tokens}")
+    print(f"Temperature: {temperature}")
+    print(f"Top-p: {top_p}")
+    
+    # Debug history
+    print("\n--- Current History ---")
+    print(f"History Type: {type(history)}")
+    print(f"History Content: {history}")
     
     # Prepare the messages for the model
     messages = []
-    if history:
-        print("Adding previous messages to the history...")
-        for entry in history:
-            messages.append({"role": "user", "content": entry[0]})
-            messages.append({"role": "assistant", "content": entry[1]})
-
-    # Add the current user message
-    print(f"Adding current user message: {message}")
-    messages.append({"role": "user", "content": message})
-
-    # Print the messages list before tokenization
-    print("Messages before tokenization:", messages)
-
-    # Tokenize the input (prepare the data for the model)
-    print("Preparing the input for the model...")
-    inputs = tokenizer.apply_chat_template(
-        messages,
-        tokenize=True,
-        add_generation_prompt=True,
-        return_tensors="pt",
-    ).to("cuda" if torch.cuda.is_available() else "cpu")
-
-    # Print the tokenized inputs
-    print(f"Tokenized inputs: {inputs}")
-
-    # Generate the response
-    attention_mask = inputs.ne(tokenizer.pad_token_id).long()
-    print(f"Attention mask: {attention_mask}")
-
     try:
-        generated_tokens = model.generate(
-            input_ids=inputs,
-            attention_mask=attention_mask,
-            max_new_tokens=max_tokens,
-            use_cache=True,
-            temperature=temperature,
-            top_p=top_p,
-        )
-    except Exception as e:
-        print(f"Error during model generation: {e}")
-        return []
-
-    # Decode the generated response
-    response = tokenizer.decode(generated_tokens[0], skip_special_tokens=True)
-    print(f"Generated response: {response}")
+        if history:
+            print("\n--- Processing Existing History ---")
+            for entry in history:
+                print(f"Processing entry: {entry}")
+                # Ensure entry is a dictionary with 'user' and 'assistant' keys
+                if isinstance(entry, dict):
+                    messages.append({"role": "user", "content": entry.get('user', '')})
+                    messages.append({"role": "assistant", "content": entry.get('assistant', '')})
+                elif isinstance(entry, list) and len(entry) == 2:
+                    # Handle case where history might be a list of [user, assistant]
+                    messages.append({"role": "user", "content": entry[0]})
+                    messages.append({"role": "assistant", "content": entry[1]})
+                else:
+                    print(f"WARNING: Unexpected history entry format: {entry}")
+        
+        # Add the current user message
+        print("\n--- Adding Current Message ---")
+        messages.append({"role": "user", "content": message})
+        
+        # Debug messages before tokenization
+        print("\n--- Messages Before Tokenization ---")
+        for msg in messages:
+            print(f"Role: {msg['role']}, Content: {msg['content']}")
+        
+        # Tokenize the input
+        print("\n--- Tokenizing Input ---")
+        inputs = tokenizer.apply_chat_template(
+            messages,
+            tokenize=True,
+            add_generation_prompt=True,
+            return_tensors="pt",
+        ).to("cuda" if torch.cuda.is_available() else "cpu")
+        
+        print(f"Tokenized Inputs Shape: {inputs.shape}")
+        print(f"Tokenized Inputs Device: {inputs.device}")
+        
+        # Generate response
+        attention_mask = inputs.ne(tokenizer.pad_token_id).long()
+        
+        try:
+            generated_tokens = model.generate(
+                input_ids=inputs,
+                attention_mask=attention_mask,
+                max_new_tokens=max_tokens,
+                use_cache=True,
+                temperature=temperature,
+                top_p=top_p,
+            )
+            
+            # Decode the generated response
+            response = tokenizer.decode(generated_tokens[0], skip_special_tokens=True)
+            print("\n--- Generated Response ---")
+            print(f"Raw Response: {response}")
+            
+            # Check and filter response
+            if "system" in response.lower():
+                print("WARNING: System message detected in response")
+                response = "Hello! How can I assist you today?"
+            
+            # Prepare return history
+            return_history = (history or []) + [
+                {"user": message, "assistant": response}
+            ]
+            
+            print("\n--- Return History ---")
+            print(f"Return History Length: {len(return_history)}")
+            for entry in return_history:
+                print(f"User: {entry['user']}")
+                print(f"Assistant: {entry['assistant'][:100]}...")  # Truncate long responses
+            
+            return return_history
+        
+        except Exception as gen_error:
+            print("\n--- GENERATION ERROR ---")
+            print(f"Error during model generation: {gen_error}")
+            return []
     
-    # Check and filter out unwanted system-level messages or metadata
-    if "system" in response.lower():
-        print("System message detected. Replacing with fallback response.")
-        response = "Hello! How can I assist you today?"
-
-    # Prepare the return format for Gradio (list of [user_message, assistant_message])
-    if history is None:
-        history = []
-    
-    # Append the new conversation turn
-    history.append([message, response])
-
-    return history
+    except Exception as prep_error:
+        print("\n--- PREPARATION ERROR ---")
+        print(f"Error during message preparation: {prep_error}")
+        return []
 
 # Define the Gradio interface
 demo = gr.ChatInterface(
@@ -92,6 +127,7 @@ demo = gr.ChatInterface(
         gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
         gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Top-p"),
     ],
+    type="messages"  # Explicitly set to messages type
 )
 
 if __name__ == "__main__":