Upload 7 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Notebook/Audio_Classification.ipynb filter=lfs diff=lfs merge=lfs -text
+Results/Spectrogram_CNN_Audio_Classification.mp4 filter=lfs diff=lfs merge=lfs -text

Notebook/Audio_Classification.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8cb22d1805365cd4f49be6a64c2423bdee83c0e733f559aa8522e548abeec0f8
+size 27944834

Results/Spectrogram_CNN_Audio_Classification.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e0554281b204fb323d23c248d818442ec755b81763947b384c7564a4e0143be5
+size 9934237

app/main.py

@@ -0,0 +1,56 @@
+from fastapi import FastAPI, UploadFile, File
+from fastapi.responses import JSONResponse
+import tempfile, shutil
+from app.preprocess import preprocess_audio
+from app.model import predict
+import numpy as np
+
+app = FastAPI(title="General Audio Classifier")
+
+@app.post("/predict")
+async def predict_audio(file: UploadFile = File(...)):
+    try:
+        # Save uploaded file temporarily
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp:
+            shutil.copyfileobj(file.file, tmp)
+            tmp_path = tmp.name
+
+        # Preprocess → multiple spectrograms
+        imgs = preprocess_audio(tmp_path)
+
+        # Predict all chunks
+        all_preds = []
+        all_confidences = []
+        for img in imgs:
+            label, confidence, probs = predict(img)
+            all_preds.append(label)
+            all_confidences.append(confidence)
+
+        # Combine predictions (majority vote with confidence tiebreaker)
+        from collections import Counter, defaultdict
+        counter = Counter(all_preds)
+        max_count = max(counter.values())
+        candidates = [k for k, v in counter.items() if v == max_count]
+
+        if len(candidates) == 1:
+            final_label = candidates[0]
+        else:
+            # Tie-breaker using sum of confidences
+            confidence_sums = defaultdict(float)
+            for i, label in enumerate(all_preds):
+                if label in candidates:
+                    confidence_sums[label] += all_confidences[i]
+            final_label = max(confidence_sums, key=confidence_sums.get)
+
+        # Average confidence for final label
+        final_confidence = np.mean([all_confidences[i] for i, label in enumerate(all_preds) if label == final_label])
+
+        return JSONResponse(content={
+            "predicted_label": final_label,
+            "confidence": round(final_confidence, 3),
+            "all_predictions": all_preds,
+            "all_confidences": [round(c,3) for c in all_confidences]
+        })
+
+    except Exception as e:
+        return JSONResponse(content={"error": str(e)}, status_code=500)

app/model.py

@@ -0,0 +1,44 @@
+import tensorflow as tf
+import numpy as np
+
+# Load trained model
+model = tf.keras.models.load_model("saved_model/Audio_Model_Classification.h5")
+
+# IMPORTANT: Keep same order as training (alphabetical default in TF)
+CLASS_NAMES = ["Baby Cry", "Chainsaw", "Clock Tick", "Cow", "Dog", "Fire Crackling", "Frog", "Helicopter", "Person Sneeze", "Pig", "Rain", "Rooster", "Sea Waves"]
+
+def predict(img):
+    # Convert PIL image → numpy array
+    img = np.array(img).astype("float32") / 255.0  # normalize [0,1]
+
+    # Resize to match training target (231x232)
+    img = tf.image.resize(img, (231, 232))  # (231, 232, 4)
+
+    # Add batch dimension
+    img = np.expand_dims(img, axis=0)  # (1, 231, 232, 4)
+
+    # Predict
+    preds = model.predict(img)
+    probs = preds[0]
+
+    class_idx = int(np.argmax(probs))
+    confidence = float(np.max(probs))
+    prob_dict = {CLASS_NAMES[i]: float(probs[i]) for i in range(len(CLASS_NAMES))}
+
+    return CLASS_NAMES[class_idx], confidence, prob_dict
+
+# THIS OUR PAST VERSION OF... IT WAS OUT RESIZING BUT EVEN THOUGH THE MODEL WAS WORKING FINE, SO, MAYBE TF COULD ACCEPT DYNAMIC SIZES OF INPUT IMAGES
+# def predict(img):
+#     # Convert to numpy array (RGBA)
+#     img = np.array(img) / 255.0  # shape (H, W, 4)
+#     img = np.expand_dims(img, axis=0)  # (1, H, W, 4)
+#
+#     # Predict
+#     preds = model.predict(img)
+#     probs = preds[0]
+#
+#     class_idx = int(np.argmax(probs))
+#     confidence = float(np.max(probs))
+#     prob_dict = {CLASS_NAMES[i]: float(probs[i]) for i in range(len(CLASS_NAMES))}
+#
+#     return CLASS_NAMES[class_idx], confidence, prob_dict

app/preprocess.py

@@ -0,0 +1,55 @@
+import librosa
+import librosa.display
+import numpy as np
+import matplotlib.pyplot as plt
+import io
+from PIL import Image
+
+# Audio parameters
+SR = 16000
+N_FFT = 1024
+HOP_LENGTH = 512
+N_MELS = 128
+TARGET_DURATION = 5.0
+TARGET_LENGTH = int(TARGET_DURATION * SR)
+
+def preprocess_audio(file_path):
+    # Load audio (force mono)
+    y, sr = librosa.load(file_path, sr=None, mono=True)
+
+    # Normalize amplitude
+    peak = np.abs(y).max()
+    if peak > 0:
+        y = y / peak * 0.99
+
+    # Resample
+    if sr != SR:
+        y = librosa.resample(y, orig_sr=sr, target_sr=SR)
+
+    # Split audio into 5s chunks
+    chunks = []
+    for start in range(0, len(y), TARGET_LENGTH):
+        chunk = y[start:start + TARGET_LENGTH]
+        if len(chunk) < TARGET_LENGTH:
+            chunk = np.pad(chunk, (0, TARGET_LENGTH - len(chunk)), mode="constant")
+
+        # Convert to Mel-spectrogram
+        S = librosa.feature.melspectrogram(
+            y=chunk, sr=SR, n_fft=N_FFT, hop_length=HOP_LENGTH, n_mels=N_MELS
+        )
+        S_dB = librosa.power_to_db(S, ref=np.max)
+
+        # Convert spectrogram to RGBA image
+        fig = plt.figure(figsize=(3, 3))
+        librosa.display.specshow(S_dB, sr=SR, hop_length=HOP_LENGTH, cmap="magma")
+        plt.axis("off")
+
+        buf = io.BytesIO()
+        plt.savefig(buf, format="png", bbox_inches="tight", pad_inches=0)
+        plt.close(fig)
+
+        buf.seek(0)
+        img = Image.open(buf).convert("RGBA")  # 4 channels
+        chunks.append(img)
+
+    return chunks

requirements.txt

@@ -0,0 +1,10 @@
+#fastapi
+#uvicorn
+tensorflow
+numpy
+librosa
+matplotlib
+soundfile
+#python-multipart
+gradio
+Pillow

saved_model/Audio_Model_Classification.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ceef1269f64afc26d31dc35e4bcacf68c2d91181aa28afeecec0e2403aabf739
+size 22083448