ongoing struggles 12

app.py

@@ -87,20 +87,16 @@ if not st.session_state.model_loaded:
         with st.spinner("Loading the fine-tuned model... This may take a minute."):
             # Check if CUDA is available, otherwise use CPU
             device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-            st.write(f"Using device: {device}")
             
             # Load tokenizer
-            st.write("Loading tokenizer...")
             tokenizer = AutoTokenizer.from_pretrained(
                 "microsoft/phi-2", 
                 trust_remote_code=True
             )
             if tokenizer.pad_token is None or tokenizer.pad_token == tokenizer.eos_token:
                 tokenizer.pad_token = tokenizer.unk_token
-            st.write("Tokenizer loaded successfully")
             
             # Load base model with simpler configuration for CPU
-            st.write("Loading base model...")
             base_model = AutoModelForCausalLM.from_pretrained(
                 "microsoft/phi-2",
                 trust_remote_code=True,
@@ -108,24 +104,18 @@ if not st.session_state.model_loaded:
                 low_cpu_mem_usage=True
             )
             base_model = base_model.to(device)
-            st.write("Base model loaded successfully")
             
             # Check if model path exists
             model_path = "./final_model"
-            st.write(f"Checking model path: {model_path}")
             if os.path.exists(model_path):
-                st.write(f"Model path exists. Contents: {os.listdir(model_path)}")
-                
                 try:
                     # Load the fine-tuned LoRA adapter
-                    st.write("Loading fine-tuned adapter...")
                     model = PeftModel.from_pretrained(
                         base_model,
                         model_path,
                         device_map=None  # Don't use device_map on CPU
                     )
                     model = model.to(device)
-                    st.write("Fine-tuned adapter loaded successfully")
                     
                     model.eval()  # Set model to evaluation mode
                     
@@ -133,21 +123,15 @@ if not st.session_state.model_loaded:
                     st.session_state.model = model
                     st.session_state.tokenizer = tokenizer
                     st.session_state.model_loaded = True
-                    st.success("Fine-tuned model loaded successfully!")
                 except Exception as e:
-                    st.error(f"Error loading fine-tuned adapter: {str(e)}")
-                    st.write(f"Error details: {type(e).__name__}")
                     # Fall back to base model
-                    st.warning("Falling back to base model")
                     model = base_model
                     model.eval()
                     st.session_state.model = model
                     st.session_state.tokenizer = tokenizer
                     st.session_state.model_loaded = True
             else:
-                st.error(f"Model path {model_path} does not exist!")
                 # Fall back to base model
-                st.warning("Falling back to base model")
                 model = base_model
                 model.eval()
                 st.session_state.model = model
@@ -155,14 +139,11 @@ if not st.session_state.model_loaded:
                 st.session_state.model_loaded = True
     except Exception as e:
         st.error(f"Error loading model: {str(e)}")
-        st.write(f"Error details: {type(e).__name__}")
 
-# Function to generate response - focused on early stopping
+# Function to generate response - clean version without debug output
 def generate_response(model, tokenizer, prompt):
-    st.write("Generating response...")
     try:
         inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
-        st.write("Input tokenized")
         
         # Define stopping words and get their token IDs
         stop_words = ["Human:", "User:"]
@@ -178,8 +159,6 @@ def generate_response(model, tokenizer, prompt):
         all_stop_ids = stop_token_ids + [tokenizer.eos_token_id]
         
         with torch.no_grad():
-            st.write("Starting generation...")
-            
             # Generate with combined stop tokens
             outputs = model.generate(
                 input_ids=inputs["input_ids"],
@@ -189,21 +168,17 @@ def generate_response(model, tokenizer, prompt):
                 pad_token_id=tokenizer.pad_token_id,
                 eos_token_id=all_stop_ids  # Only specify once
             )
-            st.write("Generation completed")
         
         # Extract just the new tokens
         input_length = inputs["input_ids"].shape[1]
         response = tokenizer.decode(outputs[0][input_length:], skip_special_tokens=True)
-        st.write(f"Raw response: '{response}'")
         
         # Minimal cleaning - just remove any "Assistant:" prefix
         if response.startswith("Assistant:"):
             response = response[len("Assistant:"):].strip()
         
-        st.write(f"Cleaned response: '{response}'")
         return response
     except Exception as e:
-        st.write(f"Error in generate_response: {str(e)}")
         return f"Error generating response: {str(e)}"
 
 # Display chat messages