added notebook

notebook.ipynb

@@ -0,0 +1,282 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install transformers torch torchaudio librosa pandas scikit-learn tqdm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "from transformers import AutoModel\n",
+    "import librosa\n",
+    "import os\n",
+    "import pandas as pd\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import accuracy_score\n",
+    "import numpy as np\n",
+    "from tqdm import tqdm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ESC50Dataset(Dataset):\n",
+    "    def __init__(self, audio_dir, metadata_path, sr=16000, max_length=160000):\n",
+    "        self.audio_dir = audio_dir\n",
+    "        self.sr = sr\n",
+    "        self.max_length = max_length\n",
+    "        self.metadata = pd.read_csv(metadata_path)\n",
+    "    \n",
+    "    def __len__(self):\n",
+    "        return len(self.metadata)\n",
+    "    \n",
+    "    def __getitem__(self, idx):\n",
+    "        row = self.metadata.iloc[idx]\n",
+    "        filename = row['filename']\n",
+    "        label = row['target']\n",
+    "        \n",
+    "        audio_path = os.path.join(self.audio_dir, filename)\n",
+    "        audio, sr = librosa.load(audio_path, sr=self.sr)\n",
+    "        \n",
+    "        audio_tensor = torch.tensor(audio).float()\n",
+    "        label_tensor = torch.tensor(label).long()\n",
+    "        \n",
+    "        return audio_tensor, label_tensor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def download_esc50():\n",
+    "    import urllib.request\n",
+    "    import zipfile\n",
+    "    \n",
+    "    if not os.path.exists('ESC-50'):\n",
+    "        print(\"Downloading ESC-50 dataset...\")\n",
+    "        url = \"https://github.com/karoldvl/ESC-50/archive/master.zip\"\n",
+    "        urllib.request.urlretrieve(url, 'esc50.zip')\n",
+    "        \n",
+    "        with zipfile.ZipFile('esc50.zip', 'r') as zip_ref:\n",
+    "            zip_ref.extractall('.')\n",
+    "        os.rename('ESC-50-master', 'ESC-50')\n",
+    "        os.remove('esc50.zip')\n",
+    "        print(\"ESC-50 dataset downloaded and extracted\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_embedding_dim(model):\n",
+    "    dummy_input = torch.randn(1, 160000)\n",
+    "    with torch.no_grad():\n",
+    "        output = model(dummy_input)\n",
+    "        if isinstance(output, dict):\n",
+    "            for key in ['last_hidden_state', 'embeddings', 'audio']:\n",
+    "                if key in output:\n",
+    "                    features = output[key]\n",
+    "                    break\n",
+    "            else:\n",
+    "                features = list(output.values())[0]\n",
+    "        else:\n",
+    "            features = output\n",
+    "        \n",
+    "        if features.dim() > 2:\n",
+    "            embedding_dim = features.shape[-1]\n",
+    "        else:\n",
+    "            embedding_dim = features.shape[-1]\n",
+    "    \n",
+    "    return embedding_dim"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Download dataset\n",
+    "download_esc50()\n",
+    "\n",
+    "# Load model\n",
+    "model = AutoModel.from_pretrained(\"mispeech/dashengtokenizer\", trust_remote_code=True)\n",
+    "\n",
+    "# Get embedding dimension\n",
+    "embedding_dim = get_embedding_dim(model)\n",
+    "print(f\"Model embedding dimension: {embedding_dim}\")\n",
+    "\n",
+    "# Freeze model\n",
+    "for param in model.parameters():\n",
+    "    param.requires_grad = False\n",
+    "\n",
+    "# Single linear layer\n",
+    "classifier = nn.Linear(embedding_dim, 50)  # 50 ESC-50 classes\n",
+    "\n",
+    "# Setup\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "model.to(device)\n",
+    "classifier.to(device)\n",
+    "print(f\"Using device: {device}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create datasets\n",
+    "audio_dir = 'ESC-50/audio'\n",
+    "metadata_path = 'ESC-50/meta/esc50.csv'\n",
+    "\n",
+    "dataset = ESC50Dataset(audio_dir, metadata_path)\n",
+    "\n",
+    "# Split into train/val\n",
+    "train_idx, val_idx = train_test_split(range(len(dataset)), test_size=0.2, random_state=42)\n",
+    "train_dataset = torch.utils.data.Subset(dataset, train_idx)\n",
+    "val_dataset = torch.utils.data.Subset(dataset, val_idx)\n",
+    "\n",
+    "train_loader = DataLoader(train_dataset, batch_size=4, shuffle=True, num_workers=2)\n",
+    "val_loader = DataLoader(val_dataset, batch_size=4, shuffle=False, num_workers=2)\n",
+    "\n",
+    "print(f\"Train samples: {len(train_dataset)}, Val samples: {len(val_dataset)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Training setup\n",
+    "optimizer = torch.optim.Adam(classifier.parameters(), lr=1e-3)\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "\n",
+    "# Training loop\n",
+    "for epoch in range(10):\n",
+    "    model.eval()\n",
+    "    classifier.train()\n",
+    "    \n",
+    "    # Training\n",
+    "    train_loss = 0\n",
+    "    train_preds = []\n",
+    "    train_labels = []\n",
+    "\n",
+    "    pbar = tqdm(train_loader, desc=f'Epoch {epoch+1}/10 Training')\n",
+    "    for batch_audio, batch_labels in pbar:\n",
+    "        batch_audio = batch_audio.to(device)\n",
+    "        batch_labels = batch_labels.to(device)\n",
+    "\n",
+    "        # Forward through frozen model\n",
+    "        with torch.no_grad():\n",
+    "            features = model.encode(batch_audio)\n",
+    "            if isinstance(features, dict):\n",
+    "                for key in ['last_hidden_state', 'embeddings', 'audio']:\n",
+    "                    if key in features:\n",
+    "                        features = features[key]\n",
+    "                        break\n",
+    "                else:\n",
+    "                    features = list(features.values())[0]\n",
+    "\n",
+    "            # Global average pooling if needed\n",
+    "            if features.dim() > 2:\n",
+    "                features = features.mean(dim=1)\n",
+    "\n",
+    "        # Classifier\n",
+    "        logits = classifier(features)\n",
+    "        loss = criterion(logits, batch_labels)\n",
+    "\n",
+    "        # Backward\n",
+    "        optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "\n",
+    "        train_loss += loss.item()\n",
+    "        preds = torch.argmax(logits, dim=1)\n",
+    "        train_preds.extend(preds.cpu().numpy())\n",
+    "        train_labels.extend(batch_labels.cpu().numpy())\n",
+    "\n",
+    "        # Update progress bar\n",
+    "        pbar.set_postfix({'loss': f'{loss.item():.4f}'})\n",
+    "\n",
+    "    train_acc = accuracy_score(train_labels, train_preds)\n",
+    "    \n",
+    "    # Validation\n",
+    "    classifier.eval()\n",
+    "    val_preds = []\n",
+    "    val_labels = []\n",
+    "\n",
+    "    with torch.no_grad():\n",
+    "        pbar_val = tqdm(val_loader, desc=f'Epoch {epoch+1}/10 Validation')\n",
+    "        for batch_audio, batch_labels in pbar_val:\n",
+    "            batch_audio = batch_audio.to(device)\n",
+    "            batch_labels = batch_labels.to(device)\n",
+    "\n",
+    "            features = model(batch_audio)\n",
+    "            if isinstance(features, dict):\n",
+    "                for key in ['last_hidden_state', 'embeddings', 'audio']:\n",
+    "                    if key in features:\n",
+    "                        features = features[key]\n",
+    "                        break\n",
+    "                else:\n",
+    "                    features = list(features.values())[0]\n",
+    "\n",
+    "            if features.dim() > 2:\n",
+    "                features = features.mean(dim=1)\n",
+    "\n",
+    "            logits = classifier(features)\n",
+    "            preds = torch.argmax(logits, dim=1)\n",
+    "            val_preds.extend(preds.cpu().numpy())\n",
+    "            val_labels.extend(batch_labels.cpu().numpy())\n",
+    "\n",
+    "            # Update validation progress bar\n",
+    "            batch_acc = (preds == batch_labels).float().mean().item()\n",
+    "            pbar_val.set_postfix({'batch_acc': f'{batch_acc:.4f}'})\n",
+    "\n",
+    "    val_acc = accuracy_score(val_labels, val_preds)\n",
+    "    \n",
+    "    print(f\"Epoch {epoch+1}/10 - Train Loss: {train_loss/len(train_loader):.4f} - Train Acc: {train_acc:.4f} - Val Acc: {val_acc:.4f}\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}