Fixed audio

app.py

@@ -27,7 +27,6 @@ client = Groq(api_key=GROQ_API_KEY)
 
 device = "cuda" if torch.cuda.is_available() else "cpu"
 
-# -----------------------------
 # TEXT DETECTION
 # -----------------------------
 def run_hf_detector(text, model_id="roberta-base-openai-detector"):
@@ -154,43 +153,100 @@ def analyze_video(video_path):
 # AUDIO DETECTION
 # -----------------------------
 class AudioCNNRNN(nn.Module):
-    def __init__(self,lstm_hidden_size=128,num_classes=2):
-        super().__init__()
+    def __init__(self, lstm_hidden_size=128, num_classes=2):
+        super(AudioCNNRNN, self).__init__()
         self.cnn = nn.Sequential(
-            nn.Conv2d(1,32,3,1,1), nn.ReLU(), nn.MaxPool2d(2),
-            nn.Conv2d(32,64,3,1,1), nn.ReLU(), nn.MaxPool2d(2)
+            nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+            nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
         )
-        self.lstm = nn.LSTM(input_size=64, hidden_size=lstm_hidden_size,batch_first=True)
-        self.fc = nn.Linear(lstm_hidden_size,num_classes)
-    def forward(self,x):
-        b,s,c,h,w = x.size()
-        x = self.cnn(x.view(b*s,c,h,w)).mean(dim=[2,3]).view(b,s,-1)
-        out,_ = self.lstm(x)
-        return self.fc(out[:,-1,:])
+        self.lstm = nn.LSTM(input_size=64, hidden_size=lstm_hidden_size, batch_first=True)
+        self.fc = nn.Linear(lstm_hidden_size, num_classes)
+
+    def forward(self, x):
+        batch_size, seq_len, c, h, w = x.size()
+        c_in = x.view(batch_size * seq_len, c, h, w)
+        features = self.cnn(c_in)
+        features = features.mean(dim=[2, 3])
+        features = features.view(batch_size, seq_len, -1)
+        lstm_out, _ = self.lstm(features)
+        out = self.fc(lstm_out[:, -1, :])
+        return out
 
 def extract_mel_spectrogram(audio_path, sr=16000, n_mels=64):
-    waveform,_ = librosa.load(audio_path,sr=sr)
-    mel_spec = librosa.feature.melspectrogram(waveform,sr,n_mels=n_mels)
-    return librosa.power_to_db(mel_spec,ref=np.max)
-
-def slice_spectrogram(mel_spec,slice_size=128,step=64):
-    return [mel_spec[:,i:i+slice_size] for i in range(0, mel_spec.shape[1]-slice_size, step)]
-
+    waveform, sample_rate = librosa.load(audio_path, sr=sr)
+    mel_spec = librosa.feature.melspectrogram(y=waveform, sr=sr, n_mels=n_mels)
+    mel_spec_db = librosa.power_to_db(mel_spec, ref=np.max)
+    return mel_spec_db
+
+def slice_spectrogram(mel_spec, slice_size=128, step=64):
+    slices = []
+    for start in range(0, mel_spec.shape[1] - slice_size, step):
+        slice_ = mel_spec[:, start:start + slice_size]
+        slices.append(slice_)
+    return slices
 def analyze_audio(audio_path):
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    model = AudioCNNRNN().to(device).eval()
+
+    model = AudioCNNRNN()
+    model.eval()
+    model.to(device)
+
     mel_spec = extract_mel_spectrogram(audio_path)
-    slices = slice_spectrogram(mel_spec)
-    if not slices: return {"ai_probability":0,"confidence":"Low","explanation":"Audio too short."}
-    data = torch.stack([torch.tensor(s).unsqueeze(0) for s in slices]).unsqueeze(0).to(device)
-    with torch.no_grad(): logits = model(data)
-    probabilities = torch.nn.functional.softmax(logits/3.0, dim=-1)[0]
-    ai_prob,human_prob = probabilities[0].item(),probabilities[1].item()
-    diff = abs(ai_prob-human_prob)
-    confidence = "High" if diff>=0.7 else "Medium" if diff>=0.3 else "Low"
-    prompt = f"Audio AI:{ai_prob:.4f} Human:{human_prob:.4f} Confidence:{confidence}. Explain reasoning."
-    response = client.chat.completions.create(model="llama-3.3-70b-versatile", messages=[{"role":"user","content":prompt}], temperature=0.6)
-    return {"ai_probability":ai_prob,"confidence":confidence,"explanation":response.choices[0].message.content.strip()}
+    mel_slices = slice_spectrogram(mel_spec, slice_size=128, step=64)
+
+    if len(mel_slices) == 0:
+        raise RuntimeError("No mel slices generated. Check audio length.")
+
+    tensor_slices = [torch.tensor(s).unsqueeze(0) for s in mel_slices]
+    data = torch.stack(tensor_slices)
+    data = data.unsqueeze(0)
+    data = data.to(device)
+
+    with torch.no_grad():
+        outputs = model(data)
+        logits = outputs
+
+    temperature = 3.0
+    probabilities = torch.nn.functional.softmax(logits / temperature, dim=-1)
+
+    ai_probability = probabilities[0][0].item()
+    human_probability = probabilities[0][1].item()
+
+    diff = abs(ai_probability - human_probability)
+    if diff >= 0.7:
+        confidence = "High"
+    elif diff >= 0.3:
+        confidence = "Medium"
+    else:
+        confidence = "Low"
+
+    prompt = f"""
+    You are an AI audio analysis expert.
+    The detector outputs:
+    - AI-generated probability: {ai_probability:.4f}
+    - Human-generated probability: {human_probability:.4f}
+    - Confidence level: {confidence}
+
+    Give a short, human-readable explanation (1-2 sentences) of why the audio was likely classified as {'AI-generated' if ai_probability > human_probability else 'human-generated'}.
+    Base it on audio cues such as tone, pitch patterns, unnatural pauses, synthesis artifacts, or other hints you might infer.
+    Avoid repeating probabilities; focus on the reasoning.
+    """
+
+    response = client.chat.completions.create(
+        model="llama-3.3-70b-versatile",
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0.6,
+    )
+
+    return {
+        "ai_probability": ai_probability,
+        "confidence": confidence,
+        "explanation": response.choices[0].message.content.strip()
+    }
 
 # -----------------------------
 # GRADIO UI
@@ -202,61 +258,17 @@ def format_text_results(text):
 
 def format_image_results(image):
     res = analyze_image(image)
-    return f"### Image Detection\nAI Probability: {res['ai_probability']:.4f}\nConfidence: {res['confidence']}\nExplanation: {res['explanation']}"
+    return f"### Image Detection\nAI Probability: {res['ai_probability']:.4f}\n\nConfidence: {res['confidence']}\n\nExplanation: {res['explanation']}"
 
 def format_video_results(video_file):
     res = analyze_video(video_file)
     if "error" in res: return res["error"]
-    return f"### Video Detection\nAI Probability: {res['ai_probability']:.4f}\nConfidence: {res['confidence']}\nExplanation: {res['explanation']}"
+    return f"### Video Detection\nAI Probability: {res['ai_probability']:.4f}\n\nConfidence: {res['confidence']}\n\nExplanation: {res['explanation']}"
 
 def format_audio_results(audio_file):
     res = analyze_audio(audio_file)
-    return f"### Audio Detection\nAI Probability: {res['ai_probability']:.4f}\nConfidence: {res['confidence']}\nExplanation: {res['explanation']}"
-
-# with gr.Blocks() as app:
-#     home = gr.Column(visible=True)
-#     with home:
-#         gr.Markdown("## AI Multi-Modal Detector")
-#         with gr.Row():
-#             t_btn = gr.Button("Text")
-#             i_btn = gr.Button("Image")
-#             v_btn = gr.Button("Video")
-#             a_btn = gr.Button("Audio")
-
-#     text_page = gr.Column(visible=False)
-#     with text_page:
-#         inp = gr.Textbox(lines=5, placeholder="Paste text...", label="Text")
-#         out = gr.Markdown()
-#         gr.Button("Analyze").click(format_text_results, inputs=inp, outputs=out)
-#         gr.Button("Back").click(lambda: (gr.update(visible=True), gr.update(visible=False)), outputs=[home,text_page])
-
-#     image_page = gr.Column(visible=False)
-#     with image_page:
-#         inp = gr.Image(type="pil")
-#         out = gr.Markdown()
-#         gr.Button("Analyze").click(format_image_results, inputs=inp, outputs=out)
-#         gr.Button("Back").click(lambda: (gr.update(visible=True), gr.update(visible=False)), outputs=[home,image_page])
-
-#     video_page = gr.Column(visible=False)
-#     with video_page:
-#         inp = gr.Video()
-#         out = gr.Markdown()
-#         gr.Button("Analyze").click(format_video_results, inputs=inp, outputs=out)
-#         gr.Button("Back").click(lambda: (gr.update(visible=True), gr.update(visible=False)), outputs=[home,video_page])
-
-#     audio_page = gr.Column(visible=False)
-#     with audio_page:
-#         inp = gr.Audio(type="filepath")
-#         out = gr.Markdown()
-#         gr.Button("Analyze").click(format_audio_results, inputs=inp, outputs=out)
-#         gr.Button("Back").click(lambda: (gr.update(visible=True), gr.update(visible=False)), outputs=[home,audio_page])
-
-#     t_btn.click(lambda: (gr.update(visible=False), gr.update(visible=True)), outputs=[home,text_page])
-#     i_btn.click(lambda: (gr.update(visible=False), gr.update(visible=True)), outputs=[home,image_page])
-#     v_btn.click(lambda: (gr.update(visible=False), gr.update(visible=True)), outputs=[home,video_page])
-#     a_btn.click(lambda: (gr.update(visible=False), gr.update(visible=True)), outputs=[home,audio_page])
-
-# app.launch(share=True)
+    return f"### Audio Detection\nAI Probability: {res['ai_probability']:.4f}\n\nConfidence: {res['confidence']}\n\nExplanation: {res['explanation']}"
+
 with gr.Blocks() as app:
     # Home Page
     home_page = gr.Column(visible=True)
@@ -337,4 +349,7 @@ with gr.Blocks() as app:
     analyze_video_btn.click(format_video_results, inputs=video_input, outputs=video_output)
     analyze_audio_btn.click(format_audio_results, inputs=audio_input, outputs=audio_output)
 
-app.launch(share=True, debug=True)
+app.launch(share=True, debug=True)
+
+
+