Upload app.py

app.py

@@ -6,61 +6,54 @@ from torch import Tensor
 import torch.nn as nn
 from model import Model
 
-# Function to load and preprocess audio data
-def load_audio_data(path, target_length=64600):
-    try:
-        X, fs = librosa.load(path)
-        if len(X) >= target_length:
-            X = X[:target_length]
-        else:
-            X = np.pad(X, (0, target_length - len(X)))
-        return Tensor(X).unsqueeze(0), fs
-    except Exception as e:
-        print("Error loading audio:", e)
-        return None, None
-
-# Load the pre-trained model
-def load_model(model_path, device):
-    try:
-        model = Model(None, device)
-        model = nn.DataParallel(model).to(device)
-        model.load_state_dict(torch.load(model_path, map_location=device))
-        model.eval()
-        return model
-    except Exception as e:
-        print("Error loading model:", e)
-        return None
+model_path = 'final_model.pth'
+def load_data(path):
+    X, fs = librosa.load(path)
+    X_pad = pad(X,64600)
+    x_inp = Tensor(X_pad).unsqueeze(0)
+    return x_inp,fs
 
-# Function for deepfake detection
-def detect_deepfake(audio_path, model, prediction_dict):
-    try:
-        audio_data, fs = load_audio_data(audio_path)
-        if audio_data is None:
-            return "Error: Audio file could not be loaded."
-        with torch.no_grad():
-            validity_probs = model(audio_data)
-            validity_probs = torch.nn.functional.softmax(validity_probs, dim=1)
-            emotion = torch.argmax(validity_probs).item()
-        return prediction_dict[emotion]
-    except Exception as e:
-        print("Error during detection:", e)
-        return "Error occurred during detection."
+def pad(x, max_len=64600):
+    x_len = x.shape[0]
+    if x_len >= max_len:
+        return x[:max_len]
+    # need to pad
+    num_repeats = int(max_len / x_len)+1
+    padded_x = np.tile(x, (1, num_repeats))[:, :max_len][0]
+    return padded_x	
 
-# Model and prediction dictionary initialization
-model_path = 'final_model.pth'
 device = 'cuda' if torch.cuda.is_available() else 'cpu'
-model = load_model(model_path, device)
+model = Model(None, device)
+nb_params = sum([param.view(-1).size()[0] for param in model.parameters()])
+model =nn.DataParallel(model).to(device)
+
+model.load_state_dict(torch.load(model_path, map_location=device))
+print("Model loaded : {}".format(model_path))
+
+model.eval()
 prediction_dict = {0: 'Fake', 1: 'Real'}
+def Detection(audio_1):
+    
+    x_inp,fs = load_data(audio_1)
+    print(x_inp.shape)
+    validity_probs = model(x_inp)
+    validity_probs = torch.nn.functional.softmax(validity_probs, dim=1)
+    
+    emotion = torch.argmax(validity_probs).item()
+    print(emotion)
+    validity = prediction_dict[emotion]
+    # validity as a dictionary of class probabilities
+    # validity = {prediction_dict[i]: float(validity_probs[0][i]) for i in range(2)}
 
-# Setting up Gradio interface
-audio_input = gr.Audio(type="file", label="Upload Audio")
-text_output = gr.Textbox(label="Real Or Fake")
+    return validity
 
-# Launch Gradio interface
+audio_1 = gr.Audio(type="filepath", label="Audio 1")
+# text_output = gr.Textbox(label="Prediction")
+text_output = gr.Textbox(label="Similarity Score")
 gr.Interface(
-    fn=detect_deepfake,
-    inputs=audio_input,
+    fn=Detection,
+    inputs=audio_1,
     outputs=text_output,
     title="Audio Deepfake Detection",
-    description="Use a pre-trained model to detect if the uploaded audio is real or fake.",
+    description="Audio Deepfake Detection using finetuned model on for-2seconds dataset.",
 ).launch()