add files of the application

.dockerignore

@@ -0,0 +1,8 @@
+venv
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.git
+.gitignore
+.ipynb_checkpoints

.gitattributes

@@ -33,3 +33,11 @@ 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
+samples/clock_tick.wav filter=lfs diff=lfs merge=lfs -text
+samples/crying_baby.wav filter=lfs diff=lfs merge=lfs -text
+samples/dog_bark.wav filter=lfs diff=lfs merge=lfs -text
+samples/fire_crackling.wav filter=lfs diff=lfs merge=lfs -text
+samples/helicopter.wav filter=lfs diff=lfs merge=lfs -text
+samples/rain.wav filter=lfs diff=lfs merge=lfs -text
+samples/rooster.wav filter=lfs diff=lfs merge=lfs -text
+samples/sneezing.wav filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,7 @@
+venv/
+__pycache__/
+*.pyc
+*.pyo
+weights/
+stats/
+samples/

Dockerfile

@@ -1,20 +1,16 @@
-FROM python:3.13.5-slim
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
-
-EXPOSE 8501
-
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+FROM python:3.10-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 8501
+
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

README.md

@@ -1,20 +1,20 @@
----
-title: Soundedge Esc Application
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: 'Environmental sound classification application '
-license: mit
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+---
+title: SoundEdge ESC50 Classifier
+emoji: 🔊
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+app_port: 8501
+pinned: false
+short_description: ESC Application
+---
+
+# SoundEdge ESC50 Classifier
+
+This app classifies environmental sounds from WAV audio clips.
+
+## Features
+- Upload a `.wav` file
+- Try built-in sample clips
+- Switch between the original and compressed models
+- View predicted sound class and probabilities

app.py

@@ -0,0 +1,346 @@
+import os
+import tempfile
+
+import streamlit as st
+import torch
+import matplotlib.pyplot as plt
+
+from preprocessing import preprocess_audio
+from utils import load_compressed_model, load_model, predict
+from classes import ESC50_CLASSES
+
+
+ORIGINAL_MODEL_PATH   = "weights/esc50_model.pth"
+COMPRESSED_MODEL_PATH = "weights/esc50_model_compressed.pth"
+STATS_PATH   = "stats/esc50_mel_stats.json"
+SAMPLES_DIR  = "samples"
+
+# ── Page config ───────────────────────────────────────────────────────────────
+st.set_page_config(
+    page_title="SoundEdge - Environmental Sound Classification",
+    page_icon="🔊",
+    layout="centered",
+)
+
+# ── Custom CSS ────────────────────────────────────────────────────────────────
+st.markdown("""
+<style>
+/* Global */
+html, body, [data-testid="stAppViewContainer"] {
+    background-color: #0f1117;
+    color: #e0e0e0;
+}
+[data-testid="stSidebar"] { display: none; }
+.block-container { padding-top: 1.5rem !important; }
+#MainMenu, footer, header { visibility: hidden; }
+
+/* Hero banner */
+.hero {
+    background: linear-gradient(135deg, #1a1f35 0%, #0d2137 60%, #112240 100%);
+    border: 1px solid #2a3a5c;
+    border-radius: 16px;
+    padding: 1rem 2rem 1rem 2rem;
+    margin-bottom: 2rem;
+    text-align: center;
+}
+.hero h1 {
+    font-size: 2.6rem;
+    font-weight: 800;
+    background: linear-gradient(90deg, #4fc3f7, #a78bfa);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    margin: 0 0 0.4rem 0;
+}
+.hero p {
+    color: #94a3b8;
+    font-size: 1.05rem;
+    margin: 0;
+}
+
+/* Section headings */
+.section-title {
+    font-size: 0.8rem;
+    font-weight: 700;
+    color: #a78bfa;
+    text-transform: uppercase;
+    letter-spacing: 0.1em;
+    margin-bottom: 0.75rem;
+}
+
+/* Class badge pills */
+.badge-grid {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.4rem;
+    margin-bottom: 0.5rem;
+}
+.badge {
+    background: #1e293b;
+    border: 1px solid #334155;
+    border-radius: 9px;
+    padding: 0.2rem 0.4rem;
+    font-size: 0.7rem;
+    color: #cbd5e1;
+    display: inline-flex;
+    align-items: center;
+    gap: 0.4rem;
+}
+
+/* Result card */
+.result-card {
+    background: linear-gradient(135deg, #1e3a5f 0%, #1a2744 100%);
+    border: 1px solid #3b82f6;
+    border-radius: 14px;
+    padding: 1.8rem 2rem;
+    margin: 1.2rem 0 1.4rem 0;
+    text-align: center;
+}
+.result-card .label {
+    font-size: 0.78rem;
+    color: #94a3b8;
+    text-transform: uppercase;
+    letter-spacing: 0.09em;
+    margin-bottom: 0.4rem;
+}
+.result-card .class-name {
+    font-size: 2.1rem;
+    font-weight: 800;
+    color: #4fc3f7;
+    margin: 0;
+}
+.result-card .confidence {
+    font-size: 1.15rem;
+    color: #a78bfa;
+    margin-top: 0.45rem;
+}
+
+/* Top-3 progress bars */
+.prob-row { margin-bottom: 0.9rem; }
+.prob-label {
+    display: flex;
+    justify-content: space-between;
+    font-size: 0.9rem;
+    margin-bottom: 0.3rem;
+    color: #cbd5e1;
+}
+.prob-bar-bg {
+    background: #1e293b;
+    border-radius: 999px;
+    height: 10px;
+    width: 100%;
+    overflow: hidden;
+}
+.prob-bar-fill {
+    height: 100%;
+    border-radius: 999px;
+    background: linear-gradient(90deg, #4fc3f7, #a78bfa);
+}
+
+/* Divider */
+hr { border-color: #1e293b !important; }
+</style>
+""", unsafe_allow_html=True)
+
+# ── Hero ──────────────────────────────────────────────────────────────────────
+st.markdown("""
+<div class="hero">
+    <h1>🔊 SoundEdge</h1>
+    <p>Environmental Sound Classification &mdash; upload a short audio clip and let the model identify the sound.</p>
+</div>
+""", unsafe_allow_html=True)
+
+# ── Supported classes ─────────────────────────────────────────────────────────
+st.markdown('<div class="section-title">Supported Sound Classes</div>', unsafe_allow_html=True)
+badges_html = '<div class="badge-grid">'
+for cls in ESC50_CLASSES:
+    label = cls.replace('_', ' ').title()
+    badges_html += f'<span class="badge">{label}</span>'
+badges_html += '</div>'
+st.markdown(badges_html, unsafe_allow_html=True)
+
+st.divider()
+
+# ── Model ─────────────────────────────────────────────────────────────────────
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+@st.cache_resource
+def get_original_model():
+    return load_model(ORIGINAL_MODEL_PATH, device, num_classes=len(ESC50_CLASSES))
+
+@st.cache_resource
+def get_compressed_model():
+    return load_compressed_model(ORIGINAL_MODEL_PATH, COMPRESSED_MODEL_PATH, num_classes=len(ESC50_CLASSES))
+
+# ── Model selector ────────────────────────────────────────────────────────────
+st.markdown('<div class="section-title">Select Model</div>', unsafe_allow_html=True)
+_model_choice = st.radio(
+    "model_selector",
+    options=["Original", "Compressed"],
+    horizontal=True,
+    label_visibility="collapsed",
+)
+if _model_choice == "Compressed":
+    active_model  = get_compressed_model()
+    active_device = torch.device("cpu")
+else:
+    active_model  = get_original_model()
+    active_device = device
+
+st.divider()
+
+# ── Session state ────────────────────────────────────────────────────────────
+if "sample_to_classify" not in st.session_state:
+    st.session_state.sample_to_classify = None
+if "active_source" not in st.session_state:
+    st.session_state.active_source = None
+
+def _clear_classification_output():
+    st.session_state.sample_to_classify = None
+    st.session_state.active_source = None
+
+def _activate_upload_source():
+    st.session_state.sample_to_classify = None
+    st.session_state.active_source = "upload"
+
+# ── Audio input tabs ──────────────────────────────────────────────────────────
+st.markdown('<div class="section-title">Choose Audio Input</div>', unsafe_allow_html=True)
+
+tab_upload, tab_sample = st.tabs(["  ⬆️  Upload a File  ", "  🎵  Try a Sample  "])
+
+uploaded_file = None
+
+with tab_upload:
+    uploaded_file = st.file_uploader(
+        "WAV audio file (5 seconds recommended)",
+        type=["wav"],
+        key="uploaded_audio",
+        on_change=_activate_upload_source,
+        label_visibility="collapsed",
+    )
+    if uploaded_file is not None:
+        if not uploaded_file.name.lower().endswith(".wav"):
+            st.error("Only .wav files are supported.")
+            st.stop()
+        st.audio(uploaded_file)
+    elif st.session_state.active_source == "upload":
+        st.session_state.active_source = None
+
+with tab_sample:
+    _sample_files = (
+        sorted([f for f in os.listdir(SAMPLES_DIR) if f.lower().endswith(".wav")])
+        if os.path.isdir(SAMPLES_DIR) else []
+    )
+
+    if not _sample_files:
+        st.info("No sample files found in the samples/ folder.")
+    else:
+        def _parse_sample_name(fn: str) -> str:
+            name = os.path.splitext(fn)[0]
+            return name.replace('_', ' ').title()
+
+        _options = {_parse_sample_name(f): f for f in _sample_files}
+        _selected = st.selectbox(
+            "Pick a sample clip",
+            options=list(_options.keys()),
+            key="sample_selector",
+            on_change=_clear_classification_output,
+            label_visibility="collapsed",
+        )
+        _sample_path = os.path.join(SAMPLES_DIR, _options[_selected])
+        st.audio(_sample_path)
+        if st.button("Classify this sample  ›", use_container_width=True):
+            st.session_state.sample_to_classify = _sample_path
+            st.session_state.active_source = "sample"
+
+# ── Determine active source ───────────────────────────────────────────────────
+source_path  = None
+cleanup_temp = False
+temp_path    = None
+
+if st.session_state.active_source == "upload" and uploaded_file is not None:
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as _tmp:
+        uploaded_file.seek(0)
+        _tmp.write(uploaded_file.read())
+        temp_path = _tmp.name
+    source_path  = temp_path
+    cleanup_temp = True
+elif st.session_state.active_source == "sample" and st.session_state.sample_to_classify:
+    source_path = st.session_state.sample_to_classify
+
+# ── Inference & results ───────────────────────────────────────────────────────
+if source_path:
+    try:
+        with st.spinner("Analysing audio…"):
+            input_tensor = preprocess_audio(source_path, STATS_PATH)
+            top_class, top_prob, all_probs = predict(active_model, input_tensor, active_device)
+
+        # ── Low-confidence guard ──────────────────────────────────────────────
+        if top_prob < 0.6:
+            st.markdown("""
+            <div style="background:#1e293b;border:1px solid #475569;border-radius:14px;
+                        padding:1.8rem 2rem;margin:1.2rem 0 1.4rem 0;text-align:center;">
+                <div style="font-size:2rem;margin-bottom:0.6rem;">🎙️</div>
+                <div style="font-size:1.1rem;font-weight:700;color:#f87171;margin-bottom:0.4rem;">
+                    Unable to confidently identify the sound
+                </div>
+                <div style="color:#94a3b8;font-size:0.95rem;">
+                    Please upload a clearer audio file and try again.
+                </div>
+            </div>
+            """, unsafe_allow_html=True)
+        else:
+            # ── Result card ───────────────────────────────────────────────────
+            top_label = top_class.replace('_', ' ').title()
+            st.markdown(f"""
+            <div class="result-card">
+                <div class="label">Predicted Sound</div>
+                <div class="class-name">{top_label}</div>
+                <div class="confidence">Confidence &nbsp;{top_prob * 100:.1f}%</div>
+            </div>
+            """, unsafe_allow_html=True)
+
+            # ── Top-3 predictions ─────────────────────────────────────────────
+            st.markdown('<div class="section-title">Top 3 Predictions</div>', unsafe_allow_html=True)
+            for item in all_probs[:3]:
+                pct = item['probability'] * 100
+                lbl = item['class_name'].replace('_', ' ').title()
+                st.markdown(f"""
+                <div class="prob-row">
+                    <div class="prob-label">
+                        <span>{lbl}</span><span>{pct:.1f}%</span>
+                    </div>
+                    <div class="prob-bar-bg">
+                        <div class="prob-bar-fill" style="width:{pct:.1f}%;"></div>
+                    </div>
+                </div>
+                """, unsafe_allow_html=True)
+
+            # ── All-class probability chart ───────────────────────────────────
+            st.markdown('<div class="section-title" style="margin-top:1.6rem;">All Class Probabilities</div>', unsafe_allow_html=True)
+
+            chart_labels = [x["class_name"].replace('_', ' ').title() for x in all_probs]
+            chart_values = [x["probability"] * 100 for x in all_probs]
+            bar_colors   = ['#4fc3f7' if chart_labels[i] == top_label else '#334155'
+                            for i in range(len(chart_labels))]
+            # increase figure height if many classes to avoid cramped labels
+            fig, ax = plt.subplots(figsize=(9, 4 + len(chart_labels) * 0.1))
+            fig.patch.set_facecolor('#0f1117')
+            ax.set_facecolor('#0f1117')
+            ax.barh(chart_labels[::-1], chart_values[::-1],
+                    color=bar_colors[::-1], height=0.6, edgecolor='none')
+            ax.set_xlabel("Probability (%)", color='#94a3b8', fontsize=9)
+            ax.tick_params(colors='#cbd5e1', labelsize=8.5)
+            for spine in ax.spines.values():
+                spine.set_visible(False)
+            ax.grid(axis='x', color='#1e293b', linewidth=0.8)
+            ax.set_xlim(0, max(chart_values) * 1.18 if max(chart_values) > 0 else 100)
+            plt.tight_layout(pad=1.0)
+            st.pyplot(fig)
+            plt.close(fig)
+
+    except Exception as e:
+        st.error(f"Error during inference: {e}")
+
+    finally:
+        if cleanup_temp and temp_path and os.path.exists(temp_path):
+            os.remove(temp_path)

classes.py

@@ -0,0 +1,15 @@
+ESC10_CLASSES = [
+    'chainsaw', 
+    'clock_tick', 
+    'crackling_fire', 
+    'crying_baby', 
+    'dog', 
+    'helicopter', 
+    'rain', 
+    'rooster', 
+    'sea_waves', 
+    'sneezing'
+]
+
+
+ESC50_CLASSES = ['dog', 'rooster', 'pig', 'cow', 'frog', 'cat', 'hen', 'insects', 'sheep', 'crow', 'rain', 'sea_waves', 'crackling_fire', 'crickets', 'chirping_birds', 'water_drops', 'wind', 'pouring_water', 'toilet_flush', 'thunderstorm', 'crying_baby', 'sneezing', 'clapping', 'breathing', 'coughing', 'footsteps', 'laughing', 'brushing_teeth', 'snoring', 'drinking_sipping', 'door_wood_knock', 'mouse_click', 'keyboard_typing', 'door_wood_creaks', 'can_opening', 'washing_machine', 'vacuum_cleaner', 'clock_alarm', 'clock_tick', 'glass_breaking', 'helicopter', 'chainsaw', 'siren', 'car_horn', 'engine', 'train', 'church_bells', 'airplane', 'fireworks', 'hand_saw']

compression/pruning.py

@@ -0,0 +1,190 @@
+import torch
+import torch.nn as nn
+
+def _make_pruned_conv(old_conv: nn.Conv2d, keep_out_idx: torch.Tensor) -> nn.Conv2d:
+    """
+    Create a new Conv2d with fewer output channels (keep_out_idx),
+    copying weights/bias from old_conv.
+    """
+    device = old_conv.weight.device
+    dtype = old_conv.weight.dtype
+
+    new_out = keep_out_idx.numel()
+    new_conv = nn.Conv2d(
+        in_channels=old_conv.in_channels,
+        out_channels=new_out,
+        kernel_size=old_conv.kernel_size,
+        stride=old_conv.stride,
+        padding=old_conv.padding,
+        dilation=old_conv.dilation,
+        groups=old_conv.groups,
+        bias=(old_conv.bias is not None),
+        padding_mode=old_conv.padding_mode,
+    ).to(device=device, dtype=dtype)
+
+    with torch.no_grad():
+        new_conv.weight.copy_(old_conv.weight.data[keep_out_idx].contiguous())
+        if old_conv.bias is not None:
+            new_conv.bias.copy_(old_conv.bias.data[keep_out_idx].contiguous())
+
+    return new_conv
+
+
+def _make_pruned_bn(old_bn: nn.BatchNorm2d, keep_idx: torch.Tensor) -> nn.BatchNorm2d:
+    """
+    Create a new BatchNorm2d with fewer channels, copying params + running stats.
+    """
+    device = old_bn.weight.device
+    dtype = old_bn.weight.dtype
+
+    new_nf = keep_idx.numel()
+    new_bn = nn.BatchNorm2d(
+        num_features=new_nf,
+        eps=old_bn.eps,
+        momentum=old_bn.momentum,
+        affine=old_bn.affine,
+        track_running_stats=old_bn.track_running_stats,
+    ).to(device=device, dtype=dtype)
+
+    with torch.no_grad():
+        if old_bn.affine:
+            new_bn.weight.copy_(old_bn.weight.data[keep_idx].contiguous())
+            new_bn.bias.copy_(old_bn.bias.data[keep_idx].contiguous())
+
+        if old_bn.track_running_stats:
+            new_bn.running_mean.copy_(old_bn.running_mean.data[keep_idx].contiguous())
+            new_bn.running_var.copy_(old_bn.running_var.data[keep_idx].contiguous())
+            new_bn.num_batches_tracked.copy_(old_bn.num_batches_tracked)
+
+    return new_bn
+
+
+def prune_conv_bn_pair(conv: nn.Conv2d, bn: nn.BatchNorm2d, amount: float = 0.3):
+    """
+    Structurally prune Conv2d output channels using L1 norm.
+    Returns: (new_conv, new_bn, keep_out_idx)
+    """
+    if not (0.0 <= amount < 1.0):
+        raise ValueError("amount must be in [0, 1).")
+
+    W = conv.weight.data  # (out, in, kH, kW)
+    out_ch = W.shape[0]
+    num_prune = int(round(amount * out_ch))
+
+    if num_prune <= 0:
+        keep_idx = torch.arange(out_ch, device=W.device)
+        return conv, bn, keep_idx
+
+    # L1 norm per output channel
+    channel_l1 = W.abs().sum(dim=(1, 2, 3))  # (out,)
+
+    # Keep the highest-L1 channels
+    sorted_idx = torch.argsort(channel_l1, descending=True)
+    keep_idx = sorted_idx[num_prune:]  # (kept,)
+
+    # Keep indices sorted for nicer determinism
+    keep_idx, _ = torch.sort(keep_idx)
+
+    new_conv = _make_pruned_conv(conv, keep_idx)
+    new_bn = _make_pruned_bn(bn, keep_idx)
+
+    return new_conv, new_bn, keep_idx
+
+
+def prune_conv_input_channels(conv: nn.Conv2d, keep_in_idx: torch.Tensor) -> nn.Conv2d:
+    """
+    Prune Conv2d input channels by selecting keep_in_idx on dim=1 of weight.
+    Returns a new conv with in_channels = len(keep_in_idx).
+    """
+    device = conv.weight.device
+    dtype = conv.weight.dtype
+
+    new_in = keep_in_idx.numel()
+    new_conv = nn.Conv2d(
+        in_channels=new_in,
+        out_channels=conv.out_channels,
+        kernel_size=conv.kernel_size,
+        stride=conv.stride,
+        padding=conv.padding,
+        dilation=conv.dilation,
+        groups=conv.groups,  # assumes groups-compatible; your model uses groups=1
+        bias=(conv.bias is not None),
+        padding_mode=conv.padding_mode,
+    ).to(device=device, dtype=dtype)
+
+    with torch.no_grad():
+        # weight shape: (out, in, kH, kW)
+        new_conv.weight.copy_(conv.weight.data[:, keep_in_idx].contiguous())
+        if conv.bias is not None:
+            new_conv.bias.copy_(conv.bias.data.contiguous())
+
+    return new_conv
+
+
+def rebuild_fc_after_pruning(model: nn.Module, example_input: torch.Tensor) -> None:
+    """
+    Rebuild model.fc input dim based on the current conv/ssrp path.
+    Assumes model has attributes: conv1, conv2, conv3, ssrp_ms, flatten, fc.
+    """
+    device = next(model.parameters()).device
+    model.eval()
+    with torch.no_grad():
+        x = example_input.to(device)
+        feats = model.flatten(model.ssrp_ms(model.conv3(model.conv2(model.conv1(x)))))
+        in_dim = feats.shape[1]
+
+    old_out = model.fc.out_features
+    model.fc = nn.Linear(in_dim, old_out).to(device)
+    model.train()
+
+def apply_structural_pruning(model: nn.Module, amount: float = 0.8, example_input: torch.Tensor = torch.randn(1, 1, 40, 862)) -> nn.Module:
+    """
+    Structural channel pruning for your CNN_PCAw_SSRPMS_KAN conv blocks.
+
+    - Prunes conv1 out channels + bn1, updates conv2 input channels accordingly
+    - Prunes conv2 out channels + bn2, updates conv3 input channels accordingly
+    - Prunes conv3 out channels + bn3
+    - Optionally rebuilds fc using example_input
+
+    example_input should be shaped like your model input, e.g. (1, 1, F, T)
+    """
+    device = next(model.parameters()).device
+
+    # ---- conv1 prune (conv1[1] is Conv2d, conv1[2] is BN) ----
+    conv1_old = model.conv1[1]
+    bn1_old = model.conv1[2]
+    conv1_new, bn1_new, keep1 = prune_conv_bn_pair(conv1_old, bn1_old, amount)
+
+    model.conv1[1] = conv1_new
+    model.conv1[2] = bn1_new
+
+    # ---- conv2 input prune to match conv1 kept outputs ----
+    model.conv2[1] = prune_conv_input_channels(model.conv2[1], keep1)
+
+    # ---- conv2 prune ----
+    conv2_old = model.conv2[1]
+    bn2_old = model.conv2[2]
+    conv2_new, bn2_new, keep2 = prune_conv_bn_pair(conv2_old, bn2_old, amount)
+
+    model.conv2[1] = conv2_new
+    model.conv2[2] = bn2_new
+
+    # ---- conv3 input prune to match conv2 kept outputs ----
+    model.conv3[0] = prune_conv_input_channels(model.conv3[0], keep2)
+
+    # ---- conv3 prune ----
+    conv3_old = model.conv3[0]
+    bn3_old = model.conv3[1]
+    conv3_new, bn3_new, keep3 = prune_conv_bn_pair(conv3_old, bn3_old, amount)
+
+    model.conv3[0] = conv3_new
+    model.conv3[1] = bn3_new
+
+    # Ensure the whole model stays on the same device
+    model.to(device)
+
+    # ---- fc rebuild (needed because flatten dim changes) ----
+    if example_input is not None:
+        rebuild_fc_after_pruning(model, example_input)
+
+    return model

compression/qat.py

@@ -0,0 +1,141 @@
+import copy
+import torch
+import torch.nn as nn
+import torch.ao.quantization as tq
+
+
+class CNN_PSK_QATWrapper(nn.Module):
+    def __init__(self, base_model: nn.Module):
+        super().__init__()
+        self.m = base_model
+        self.quant_in_conv3 = tq.QuantStub()
+        self.dequant_after_conv3 = tq.DeQuantStub()
+        self.quant_in_fc = tq.QuantStub()
+        self.dequant_after_fc = tq.DeQuantStub()
+
+    def forward(self, x):
+        x = self.m.conv1(x)          # float
+        x = self.m.conv2(x)          # float
+
+        x = self.quant_in_conv3(x)   # int8-sim
+        x = self.m.conv3(x)          # quantized block
+        x = self.dequant_after_conv3(x)
+
+        x = self.m.ssrp_ms(x)        # float
+        x = self.m.flatten(x)
+
+        x = self.quant_in_fc(x)      # int8-sim
+        x = self.m.fc(x)             # quantized linear
+        x = self.dequant_after_fc(x)
+
+        x = self.m.kan(x)            # float
+        return x
+
+
+def _get_available_backend(preferred: str = "fbgemm") -> str:
+    supported = torch.backends.quantized.supported_engines
+    if preferred in supported:
+        return preferred
+    for fallback in ("qnnpack", "fbgemm", "onednn"):
+        if fallback in supported:
+            return fallback
+    raise RuntimeError(
+        f"No supported quantization backend found. Available: {supported}"
+    )
+
+
+def _set_backend(backend: str):
+    backend = _get_available_backend(backend)
+    torch.backends.quantized.engine = backend
+    return backend
+
+
+def _fuse_conv_bn_relu_for_qat(base: nn.Module):
+    if not (hasattr(base, "conv3") and isinstance(base.conv3, nn.Sequential)):
+        return
+    if len(base.conv3) < 3:
+        return
+
+    was_training = base.training
+    base.eval()
+    tq.fuse_modules(base.conv3, [["0", "1", "2"]], inplace=True)
+    if was_training:
+        base.train()
+
+def get_qat_qconfig_compatible(backend: str = "fbgemm"):
+    """
+    QAT config compatible with eager-mode convert() for Conv/Linear:
+      - Activations: quint8 per-tensor affine
+      - Weights: qint8 per-channel symmetric (supported by quantized conv/linear)
+    """
+    backend = _get_available_backend(backend)
+
+    act_fq = tq.FusedMovingAvgObsFakeQuantize.with_args(
+        observer=tq.MovingAverageMinMaxObserver,
+        dtype=torch.quint8,
+        qscheme=torch.per_tensor_affine,
+        quant_min=0,
+        quant_max=255,
+        reduce_range=False,
+    )
+
+    weight_fq = tq.FusedMovingAvgObsFakeQuantize.with_args(
+        observer=tq.MovingAveragePerChannelMinMaxObserver,
+        dtype=torch.qint8,
+        qscheme=torch.per_channel_symmetric,   # key change
+        quant_min=-128,
+        quant_max=127,
+        reduce_range=False,
+        ch_axis=0,  # Conv2d out_channels axis, Linear out_features axis
+    )
+
+    return tq.QConfig(activation=act_fq, weight=weight_fq)
+
+
+def prepare_qat_model(
+    model_fp32: nn.Module,
+    backend: str = "fbgemm",
+    inplace: bool = False,
+) -> nn.Module:
+    backend = _set_backend(backend)
+
+    base = model_fp32 if inplace else copy.deepcopy(model_fp32)
+
+    # 1) Fuse conv3 safely
+    _fuse_conv_bn_relu_for_qat(base)
+
+    # 2) Wrap
+    qat_wrapped = CNN_PSK_QATWrapper(base)
+
+    # 3) Attach QAT qconfig
+    qat_wrapped.qconfig = tq.get_default_qat_qconfig(backend)  # backend already resolved
+
+    # Keep custom / unsupported parts in float
+    qat_wrapped.m.conv1.qconfig = None
+    qat_wrapped.m.conv2.qconfig = None
+    qat_wrapped.m.ssrp_ms.qconfig = None
+    qat_wrapped.m.flatten.qconfig = None
+    qat_wrapped.m.kan.qconfig = None
+
+    # Keep PCAw_Pool float (inside conv1)
+    for mod in qat_wrapped.m.conv1.modules():
+        if mod.__class__.__name__ == "PCAw_Pool":
+            mod.qconfig = None
+
+    # 4) Prepare for QAT (inserts fake quant modules)
+    qat_wrapped.train()
+    tq.prepare_qat(qat_wrapped, inplace=True)
+
+    return qat_wrapped
+
+
+def convert_qat_model(
+    qat_model: nn.Module,
+    backend: str = "fbgemm",
+    inplace: bool = False,
+) -> nn.Module:
+    _set_backend(backend)  # will auto-resolve to supported backend
+    m = qat_model if inplace else copy.deepcopy(qat_model)
+    m.eval()
+    m = m.cpu()
+    return tq.convert(m, inplace=True)

custom_layers/PCAw_Pool.py

@@ -0,0 +1,74 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class PCAw_Pool(nn.Module):
+    def __init__(self, kernel_size, stride=(1, 1), eps: float = 1e-4, normalize_weights: bool = True):
+        super().__init__()
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.eps = eps
+        self.normalize_weights = normalize_weights
+
+        # D = number of features per patch = F_k * T_k
+        F_k, T_k = kernel_size
+        D = F_k * T_k
+
+        # Trainable weights over PCA components (columns). Shape: (D,)
+        # Initialized small to avoid overpowering early training.
+        self.weights = nn.Parameter(0.01 * torch.randn(D))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        B, C, Fh, Tw = x.shape
+        F_k, T_k = self.kernel_size
+
+        # Unfold per-channel
+        x_bc = x.view(B * C, 1, Fh, Tw)  # (B*C, 1, F, T)
+        patches = F.unfold(x_bc, kernel_size=(F_k, T_k), stride=self.stride)  # (B*C, D, NumPatches)
+        D = patches.shape[1]
+        NumPatches = patches.shape[2]
+
+        # Arrange to (B, C, NumPatches, D) -> (B, C*NumPatches, D)
+        patches = patches.permute(0, 2, 1).contiguous()         # (B*C, NumPatches, D)
+        patches = patches.view(B, C, NumPatches, D)             # (B, C, NumPatches, D)
+        X = patches.view(B, C * NumPatches, D)                  # (B, N, D) with N = C*NumPatches
+        N = X.shape[1]
+
+        # Output spatial size
+        H = (Fh - F_k) // self.stride[0] + 1
+        W = (Tw - T_k) // self.stride[1] + 1
+
+        # Center features
+        mean = X.mean(dim=1, keepdim=True)                     # (B, 1, D)
+        Xc = X - mean                                          # (B, N, D)
+
+        # Optional: standardize per-feature to tame scale explosions from DSConv
+        var = Xc.pow(2).mean(dim=1, keepdim=True)              # (B, 1, D)
+        Xc = Xc / torch.sqrt(var + 1e-6)
+
+        # --------- Stable projection basis via SVD (more robust than eigh) ---------
+        # Xc = U S V^T  -> principal components are columns of V
+        # Use full_matrices=False for efficiency and stable backward
+        U, S, Vh = torch.linalg.svd(Xc, full_matrices=False)   # Vh: (B, D, D)
+        eigvecs = Vh.transpose(1, 2)                           # (B, D, D)
+
+        # Detach eigenvectors to avoid backprop through SVD
+        eigvecs = eigvecs.detach()
+
+        # Weighted projection direction v = E @ w
+        if self.normalize_weights:
+            w = torch.softmax(self.weights, dim=0)             # (D,)
+        else:
+            w = self.weights
+
+        v = torch.matmul(eigvecs, w)                           # (B, D)
+        v = v / (v.norm(dim=1, keepdim=True) + 1e-8)           # normalize
+
+        # Project samples onto v -> scalar per sample
+        scores = torch.matmul(Xc, v.unsqueeze(-1)).squeeze(-1) # (B, N)
+
+        return scores.view(B, C, H, W)
+
+    def extra_repr(self) -> str:
+        return (f"kernel_size={self.kernel_size}, stride={self.stride}, "
+                f"eps={self.eps}, normalize_weights={self.normalize_weights}")

custom_layers/SSRP_MS.py

@@ -0,0 +1,47 @@
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+class SSRP_MS(nn.Module):
+    """
+    Multi-Scale Sparse Shift-Invariant Representation Pooling (SSRP-MS)
+
+    Given feature maps x with shape (B, C, F, T):
+      - For L scales with window sizes W_l = l * W0 (l = 1..L),
+        compute moving means along time with stride=1 (no padding).
+      - Take max over time at each scale (one max per frequency band).
+      - Average these L maxima to obtain the pooled descriptor z_c(f).
+
+    Output: (B, C, F)
+    """
+    def __init__(self, base_window: int, num_levels: int):
+        super().__init__()
+        assert base_window >= 1 and num_levels >= 1
+        self.base_window = base_window
+        self.num_levels  = num_levels
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        x: (B, C, F, T)
+        returns: (B, C, F)
+        """
+        B, C, Freq, T = x.shape
+        x_1d = x.reshape(B * C * Freq, 1, T)  # (BCF, 1, T)
+
+        level_maxes = []
+        # W_l = l * W0 (clamped to T to avoid empty pooling)
+        for l in range(1, self.num_levels + 1):
+            k = min(l * self.base_window, T)
+            # avg over time windows of length k (stride 1)
+            local_means = F.avg_pool1d(x_1d, kernel_size=k, stride=1)  # (BCF, 1, T - k + 1)
+            # max over time (Eq. 5's inner max_t)
+            max_over_t = local_means.max(dim=2)[0].squeeze(1)          # (BCF,)
+            level_maxes.append(max_over_t)
+
+        # Average across levels (1/L * sum_l ...)
+        z = torch.stack(level_maxes, dim=0).mean(dim=0)                # (BCF,)
+
+        return z.view(B, C, Freq)
+
+    def extra_repr(self) -> str:
+        return f"base_window={self.base_window}, num_levels={self.num_levels}"

custom_layers/WavKAN.py

@@ -0,0 +1,108 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+
+class WavKANLinear(nn.Module):
+    def __init__(self, in_features, out_features, wavelet_type='dog'):
+        super(WavKANLinear, self).__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.wavelet_type = wavelet_type
+        # Parameters for wavelet transformation
+        self.scale = nn.Parameter(torch.ones(out_features, in_features))
+        self.translation = nn.Parameter(torch.zeros(out_features, in_features))
+        self.wavelet_weights = nn.Parameter(torch.Tensor(out_features, in_features))
+
+        nn.init.kaiming_uniform_(self.wavelet_weights, a=math.sqrt(5))
+
+        # Base activation function #not used for this experiment
+        self.base_activation = nn.SiLU()
+
+        # Batch normalization
+        self.bn = nn.BatchNorm1d(out_features)
+
+    def wavelet_transform(self, x):
+        if x.dim() == 2:
+            x_expanded = x.unsqueeze(1)
+        else:
+            x_expanded = x
+
+        translation_expanded = self.translation.unsqueeze(0).expand(x.size(0), -1, -1)
+        scale_expanded = self.scale.unsqueeze(0).expand(x.size(0), -1, -1)
+        x_scaled = (x_expanded - translation_expanded) / scale_expanded
+
+        # Implementation of different wavelet types
+        if self.wavelet_type == 'mexican_hat':
+            term1 = ((x_scaled ** 2)-1)
+            term2 = torch.exp(-0.5 * x_scaled ** 2)
+            wavelet = (2 / (math.sqrt(3) * math.pi**0.25)) * term1 * term2
+            wavelet_weighted = wavelet * self.wavelet_weights.unsqueeze(0).expand_as(wavelet)
+            wavelet_output = wavelet_weighted.sum(dim=2)
+        elif self.wavelet_type == 'morlet':
+            omega0 = 5.0  # Central frequency
+            real = torch.cos(omega0 * x_scaled)
+            envelope = torch.exp(-0.5 * x_scaled ** 2)
+            wavelet = envelope * real
+            wavelet_weighted = wavelet * self.wavelet_weights.unsqueeze(0).expand_as(wavelet)
+            wavelet_output = wavelet_weighted.sum(dim=2)
+            
+        elif self.wavelet_type == 'dog':
+            # Implementing Derivative of Gaussian Wavelet 
+            dog = -x_scaled * torch.exp(-0.5 * x_scaled ** 2)
+            wavelet = dog
+            wavelet_weighted = wavelet * self.wavelet_weights.unsqueeze(0).expand_as(wavelet)
+            wavelet_output = wavelet_weighted.sum(dim=2)
+        elif self.wavelet_type == 'meyer':
+            # Implement Meyer Wavelet here
+            # Constants for the Meyer wavelet transition boundaries
+            v = torch.abs(x_scaled)
+            pi = math.pi
+
+            def meyer_aux(v):
+                return torch.where(v <= 1/2,torch.ones_like(v),torch.where(v >= 1,torch.zeros_like(v),torch.cos(pi / 2 * nu(2 * v - 1))))
+
+            def nu(t):
+                return t**4 * (35 - 84*t + 70*t**2 - 20*t**3)
+            # Meyer wavelet calculation using the auxiliary function
+            wavelet = torch.sin(pi * v) * meyer_aux(v)
+            wavelet_weighted = wavelet * self.wavelet_weights.unsqueeze(0).expand_as(wavelet)
+            wavelet_output = wavelet_weighted.sum(dim=2)
+        elif self.wavelet_type == 'shannon':
+            # Windowing the sinc function to limit its support
+            pi = math.pi
+            sinc = torch.sinc(x_scaled / pi)  # sinc(x) = sin(pi*x) / (pi*x)
+
+            # Applying a Hamming window to limit the infinite support of the sinc function
+            window = torch.hamming_window(x_scaled.size(-1), periodic=False, dtype=x_scaled.dtype, device=x_scaled.device)
+            # Shannon wavelet is the product of the sinc function and the window
+            wavelet = sinc * window
+            wavelet_weighted = wavelet * self.wavelet_weights.unsqueeze(0).expand_as(wavelet)
+            wavelet_output = wavelet_weighted.sum(dim=2)
+            #You can try many more wavelet types ...
+        else:
+            raise ValueError("Unsupported wavelet type")
+
+        return wavelet_output
+
+    def forward(self, x):
+        return self.bn(self.wavelet_transform(x))
+    
+    def extra_repr(self) -> str:
+        return (f"in_features={self.in_features}, out_features={self.out_features}, "
+                f"wavelet_type={self.wavelet_type}")
+
+class WavKAN(nn.Module):
+    def __init__(self, layers_hidden, wavelet_type='dog'):
+        super(WavKAN, self).__init__()
+        self.layers = nn.ModuleList()
+        self.dropout = nn.Dropout(0.5)
+        for in_features, out_features in zip(layers_hidden[:-1], layers_hidden[1:]):
+            self.layers.append(WavKANLinear(in_features, out_features, wavelet_type))
+
+    def forward(self, x):
+        for i, layer in enumerate(self.layers):
+            x = layer(x)
+            if i < len(self.layers) - 1:
+                x = self.dropout(x)
+        return x

model.py

@@ -0,0 +1,49 @@
+import torch
+import torch.nn as nn
+
+from custom_layers.SSRP_MS import SSRP_MS
+from custom_layers.WavKAN import WavKANLinear
+from custom_layers.PCAw_Pool import PCAw_Pool
+
+
+class CNN_PCAw_SSRPMS_KAN(nn.Module):
+    def __init__(self, num_classes):
+        super(CNN_PCAw_SSRPMS_KAN, self).__init__()
+
+        self.conv1 = nn.Sequential(
+            nn.ZeroPad2d((0, 0, 0, 1)),
+            nn.Conv2d(1, 64, kernel_size=3),
+            nn.BatchNorm2d(64),
+            nn.ReLU(),
+            PCAw_Pool(kernel_size=(3, 3), stride=(3, 3)),
+        )
+
+        self.conv2 = nn.Sequential(
+            nn.ZeroPad2d((0, 0, 0, 1)),
+            nn.Conv2d(64, 128, kernel_size=3),
+            nn.BatchNorm2d(128),
+            nn.ReLU(),
+            nn.AvgPool2d(kernel_size=(2, 2), stride=(2, 2)),
+        )
+
+        self.conv3 = nn.Sequential(
+            nn.Conv2d(128, 256, kernel_size=3),
+            nn.BatchNorm2d(256),
+            nn.ReLU()
+        )
+
+        self.ssrp_ms = SSRP_MS(base_window=3, num_levels=5)
+        self.flatten = nn.Flatten()
+
+        self.fc = nn.Linear(1024, 128)
+        self.kan = WavKANLinear(128, num_classes)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.conv2(x)
+        x = self.conv3(x)
+        x = self.ssrp_ms(x)
+        x = self.flatten(x)
+        x = self.fc(x)
+        x = self.kan(x)
+        return x

preprocessing.py

@@ -0,0 +1,88 @@
+import json
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torchaudio
+import soundfile as sf
+
+TARGET_SR = 44100
+TARGET_DURATION = 5
+TARGET_NUM_SAMPLES = TARGET_SR * TARGET_DURATION
+
+
+class NormalizeMeanStd(nn.Module):
+    def __init__(self, mean: float, std: float, eps: float = 1e-6):
+        super().__init__()
+        self.register_buffer("mean", torch.tensor(mean).view(1, 1, 1))
+        self.register_buffer("std", torch.tensor(std).view(1, 1, 1))
+        self.eps = eps
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return (x - self.mean) / (self.std + self.eps)
+
+
+def mel_transform_from_stats(
+    stats_path: str,
+    sample_rate: int = 44100,
+    n_fft: int = 1024,
+    hop_length: int = 256,
+    n_mels: int = 40,
+):
+    with open(stats_path, "r", encoding="utf-8") as f:
+        s = json.load(f)
+
+    return nn.Sequential(
+        torchaudio.transforms.MelSpectrogram(
+            sample_rate=sample_rate,
+            n_fft=n_fft,
+            hop_length=hop_length,
+            n_mels=n_mels,
+        ),
+        torchaudio.transforms.AmplitudeToDB(),
+        NormalizeMeanStd(s["mean"], s["std"]),
+    )
+
+
+def load_audio_with_soundfile(file_path: str):
+    waveform, sr = sf.read(file_path, always_2d=True)   # [samples, channels]
+    waveform = torch.tensor(waveform, dtype=torch.float32).transpose(0, 1)  # [channels, samples]
+    return waveform, sr
+
+
+def convert_to_mono(waveform: torch.Tensor) -> torch.Tensor:
+    if waveform.shape[0] > 1:
+        waveform = waveform.mean(dim=0, keepdim=True)
+    return waveform
+
+
+def resample_if_needed(waveform: torch.Tensor, orig_sr: int, target_sr: int = TARGET_SR) -> torch.Tensor:
+    if orig_sr != target_sr:
+        resampler = torchaudio.transforms.Resample(orig_freq=orig_sr, new_freq=target_sr)
+        waveform = resampler(waveform)
+    return waveform
+
+
+def pad_or_trim(waveform: torch.Tensor, target_num_samples: int = TARGET_NUM_SAMPLES) -> torch.Tensor:
+    num_samples = waveform.shape[1]
+
+    if num_samples > target_num_samples:
+        waveform = waveform[:, :target_num_samples]
+    elif num_samples < target_num_samples:
+        pad_amount = target_num_samples - num_samples
+        waveform = F.pad(waveform, (0, pad_amount))
+
+    return waveform
+
+
+def preprocess_audio(file_path: str, stats_path: str) -> torch.Tensor:
+    waveform, sr = load_audio_with_soundfile(file_path)
+
+    waveform = convert_to_mono(waveform)
+    waveform = resample_if_needed(waveform, sr, TARGET_SR)
+    waveform = pad_or_trim(waveform, TARGET_NUM_SAMPLES)
+
+    mel_transform = mel_transform_from_stats(stats_path=stats_path)
+    features = mel_transform(waveform)   # [1, 40, time]
+
+    features = features.unsqueeze(0)     # [1, 1, 40, time]
+    return features

requirements.txt

@@ -1,3 +1,55 @@
-altair
-pandas
-streamlit
+altair==6.0.0
+attrs==25.4.0
+blinker==1.9.0
+cachetools==7.0.3
+certifi==2026.2.25
+cffi==2.0.0
+charset-normalizer==3.4.5
+click==8.3.1
+colorama==0.4.6
+contourpy==1.3.2
+cycler==0.12.1
+filelock==3.25.0
+fonttools==4.61.1
+fsspec==2026.2.0
+gitdb==4.0.12
+GitPython==3.1.46
+idna==3.11
+Jinja2==3.1.6
+jsonschema==4.26.0
+jsonschema-specifications==2025.9.1
+kiwisolver==1.4.9
+MarkupSafe==3.0.3
+matplotlib==3.10.8
+mpmath==1.3.0
+narwhals==2.17.0
+networkx==3.4.2
+numpy==2.2.6
+packaging==26.0
+pandas==2.3.3
+pillow==12.1.1
+protobuf==6.33.5
+pyarrow==23.0.1
+pycparser==3.0
+pydeck==0.9.1
+pyparsing==3.3.2
+python-dateutil==2.9.0.post0
+pytz==2026.1.post1
+referencing==0.37.0
+requests==2.32.5
+rpds-py==0.30.0
+six==1.17.0
+smmap==5.0.2
+soundfile==0.13.1
+streamlit==1.55.0
+sympy==1.14.0
+tenacity==9.1.4
+toml==0.10.2
+torch==2.10.0
+torchaudio==2.10.0
+torchcodec==0.10.0
+tornado==6.5.4
+typing_extensions==4.15.0
+tzdata==2025.3
+urllib3==2.6.3
+watchdog==6.0.0

samples/clock_tick.wav

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

samples/crying_baby.wav

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

samples/dog_bark.wav

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

samples/fire_crackling.wav

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

samples/helicopter.wav

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

samples/rain.wav

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

samples/rooster.wav

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

samples/sneezing.wav

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

stats/esc50_mel_stats.json

@@ -0,0 +1,18 @@
+{
+  "test_fold": 1,
+  "train_folds": [
+    2,
+    3,
+    4,
+    5
+  ],
+  "sample_rate": 44100,
+  "n_fft": 1024,
+  "hop_length": 256,
+  "n_mels": 40,
+  "space": "mel_db",
+  "stat_type": "global_scalar_over_all_bins_and_frames",
+  "count": 55168000,
+  "mean": -18.729941406024793,
+  "std": 34.19103885429348
+}

utils.py

@@ -0,0 +1,61 @@
+import torch
+import torch.nn.functional as F
+
+from model import CNN_PCAw_SSRPMS_KAN
+from classes import ESC50_CLASSES
+from compression.pruning import apply_structural_pruning
+from compression.qat import prepare_qat_model, convert_qat_model
+
+def load_model(model_path: str, device: torch.device, num_classes: int):
+    model = CNN_PCAw_SSRPMS_KAN(num_classes=num_classes)
+
+    checkpoint = torch.load(model_path, map_location=device)
+
+    # Case 1: pure state_dict saved with torch.save(model.state_dict(), path)
+    try:
+        model.load_state_dict(checkpoint)
+    except RuntimeError:
+        raise ValueError("Unsupported checkpoint format.")
+
+    model.to(device)
+    model.eval()
+    return model
+
+def load_compressed_model(model_path: str, compressed_model_path: str, num_classes: int):
+    model = CNN_PCAw_SSRPMS_KAN(num_classes=num_classes)
+
+    original_checkpoint = torch.load(model_path, map_location="cpu")
+    compressed_checkpoint = torch.load(compressed_model_path, map_location="cpu")
+    try:
+        model.load_state_dict(original_checkpoint)
+        model = apply_structural_pruning(model)
+        model = prepare_qat_model(model)
+        model = convert_qat_model(model)
+        model.load_state_dict(compressed_checkpoint)
+    except RuntimeError as e:
+        print(f"Error loading compressed model: {e}")
+        raise ValueError("Unsupported checkpoint format.")
+
+    model.to("cpu")
+    model.eval()
+    return model
+
+@torch.no_grad()
+def predict(model, input_tensor: torch.Tensor, device: torch.device):
+    input_tensor = input_tensor.to(device)
+
+    logits = model(input_tensor)
+    probs = F.softmax(logits, dim=1).squeeze(0).cpu()
+
+    top_idx = torch.argmax(probs).item()
+    top_class = ESC50_CLASSES[top_idx]
+    top_prob = probs[top_idx].item()
+
+    all_probs = [
+        {"class_name": ESC50_CLASSES[i], "probability": float(probs[i])}
+        for i in range(len(ESC50_CLASSES))
+    ]
+
+    all_probs = sorted(all_probs, key=lambda x: x["probability"], reverse=True)
+
+    return top_class, top_prob, all_probs

weights/esc50_model.pth

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

weights/esc50_model_compressed.pth

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