Update app.py

app.py

@@ -12,7 +12,6 @@ import spaces
 MODEL_ID = "Qwen/Qwen-Audio-Chat"
 
 def load_model():
-    print("Loading model and tokenizer...")
     model = AutoModelForCausalLM.from_pretrained(
         MODEL_ID,
         torch_dtype=torch.float16,
@@ -21,7 +20,6 @@ def load_model():
     )
     tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True)
 
-    # Define a custom chat template
     chat_template = """<s>[INST] <<SYS>>
 You are a helpful assistant.
 <</SYS>>
@@ -29,67 +27,39 @@ You are a helpful assistant.
 {{ message['role'] }}: {{ message['content'] }}
 {% endfor %}[/INST]"""
 
-    # Assign the custom chat template to the tokenizer
     tokenizer.chat_template = chat_template
-
-    print("Model and tokenizer loaded successfully")
     return model, tokenizer
 
 def process_audio(audio_path):
-    """Process audio file for the model."""
     try:
-        print(f"Processing audio file: {audio_path}")
-        # Read audio file
         audio_data, sample_rate = sf.read(audio_path)
 
-        # Convert to mono if stereo
         if len(audio_data.shape) > 1:
             audio_data = audio_data.mean(axis=1)
 
-        # Ensure float32 format
         audio_data = audio_data.astype(np.float32)
 
-        # Create in-memory buffer
         audio_buffer = BytesIO()
-
-        # Write audio to buffer in WAV format
         sf.write(audio_buffer, audio_data, sample_rate, format='WAV')
 
-        # Get the buffer content and encode to base64
         audio_buffer.seek(0)
         audio_base64 = base64.b64encode(audio_buffer.read()).decode('utf-8')
 
-        print(f"Audio processed successfully. Sample rate: {sample_rate}, Shape: {audio_data.shape}")
         return {
             "audio": audio_base64,
             "sampling_rate": sample_rate
         }
-    except Exception as e:
-        print(f"Error processing audio: {e}")
-        import traceback
-        traceback.print_exc()
+    except Exception:
         return None
 
 @spaces.GPU
 def analyze_audio(audio_path: str, question: str = None) -> str:
-    """
-    Main function for audio analysis that will be exposed as a tool.
-    Args:
-        audio_path: Path to the audio file
-        question: Optional question about the audio
-    Returns:
-        str: Model's response about the audio
-    """
-    print(f"\nStarting analysis with audio_path: {audio_path}, question: {question}")
-
-    # Input validation
     if audio_path is None or not isinstance(audio_path, str):
         return "Please provide a valid audio file."
 
     if not os.path.exists(audio_path):
         return f"Audio file not found: {audio_path}"
 
-    # Process audio
     audio_data = process_audio(audio_path)
     if not audio_data or "audio" not in audio_data or "sampling_rate" not in audio_data:
         return "Failed to process the audio file. Please ensure it's a valid audio format."
@@ -98,7 +68,6 @@ def analyze_audio(audio_path: str, question: str = None) -> str:
         model, tokenizer = load_model()
         query = question if question else "Please describe what you hear in this audio clip."
 
-        print("Preparing messages...")
         messages = [
             {
                 "role": "user",
@@ -106,7 +75,6 @@ def analyze_audio(audio_path: str, question: str = None) -> str:
             }
         ]
 
-        print("Applying chat template...")
         if tokenizer.chat_template:
             text = tokenizer.apply_chat_template(
                 messages,
@@ -116,12 +84,8 @@ def analyze_audio(audio_path: str, question: str = None) -> str:
         else:
             raise ValueError("Tokenizer chat_template is not set.")
 
-        print(f"Generated prompt text: {text[:200]}...")
-
-        print("Tokenizing input...")
         model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
 
-        print("Generating response...")
         with torch.no_grad():
             outputs = model.generate(
                 **model_inputs,
@@ -134,24 +98,14 @@ def analyze_audio(audio_path: str, question: str = None) -> str:
             )
 
             if outputs is None or len(outputs) == 0:
-                print("Model generated None or empty output")
                 return "The model failed to generate a response. Please try again."
 
-            print(f"Output shape: {outputs.shape}")
             response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-            print(f"Generated response: {response[:200]}...")
             return response
 
-    except TypeError as te:
-        print(f"TypeError during processing: {str(te)}")
-        return "An error occurred with the data processing. Please check the inputs."
-    except Exception as e:
-        print(f"Error during processing: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        return f"An error occurred while processing: {str(e)}"
+    except Exception:
+        return "An error occurred while processing. Please check your inputs and try again."
 
-# Create Gradio interface with clear input/output specifications
 demo = gr.Interface(
     fn=analyze_audio,
     inputs=[
@@ -159,7 +113,7 @@ demo = gr.Interface(
             type="filepath",
             label="Audio Input",
             sources=["upload", "microphone"],
-            format="mp3"  # Specify format to ensure consistent audio format
+            format="mp3"
         ),
         gr.Textbox(
             label="Question",