updated

notebook.ipynb

@@ -17,6 +17,7 @@
    "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",
@@ -24,7 +25,8 @@
     "from sklearn.metrics import accuracy_score\n",
     "import numpy as np\n",
     "from tqdm import tqdm\n",
-    "import pickle"
+    "import pickle\n",
+    "from concurrent.futures import ThreadPoolExecutor"
    ]
   },
   {
@@ -33,6 +35,31 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "class ESC50Dataset(Dataset):\n",
+    "    def __init__(self, metadata_path, audio_dir, sr=16000):\n",
+    "        self.metadata = pd.read_csv(metadata_path)\n",
+    "        self.audio_dir = audio_dir\n",
+    "        self.sr = sr\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",
+    "        fold = row['fold']\n",
+    "        \n",
+    "        audio_path = os.path.join(self.audio_dir, filename)\n",
+    "        \n",
+    "        try:\n",
+    "            audio, sr = librosa.load(audio_path, sr=self.sr)\n",
+    "            return audio, label, fold\n",
+    "        except Exception as e:\n",
+    "            print(f\"Error loading {audio_path}: {e}\")\n",
+    "            # Return zeros if file can't be loaded\n",
+    "            return np.zeros(16000), label, fold\n",
+    "\n",
     "def download_esc50():\n",
     "    import urllib.request\n",
     "    import zipfile\n",
@@ -46,17 +73,46 @@
     "            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": [
+    "        print(\"ESC-50 dataset downloaded and extracted\")\n",
+    "\n",
+    "def extract_features_batch(audio_batch, model, device):\n",
+    "    \"\"\"Extract features for a batch of audio\"\"\"\n",
+    "    audio_tensors = []\n",
+    "    \n",
+    "    for audio in audio_batch:\n",
+    "        # Ensure audio is the right length\n",
+    "        if len(audio) < 16000:\n",
+    "            audio = np.pad(audio, (0, 16000 - len(audio)))\n",
+    "        elif len(audio) > 16000:\n",
+    "            audio = audio[:16000]\n",
+    "        \n",
+    "        audio_tensor = torch.tensor(audio).float().unsqueeze(0).to(device)\n",
+    "        audio_tensors.append(audio_tensor)\n",
+    "    \n",
+    "    # Batch process\n",
+    "    if audio_tensors:\n",
+    "        batch_audio = torch.cat(audio_tensors, dim=0)\n",
+    "        \n",
+    "        with torch.no_grad(), torch.autocast(device_type='cuda' if device.type == 'cuda' else 'cpu'):\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\n",
+    "            if features.dim() > 2:\n",
+    "                features = features.mean(dim=1)\n",
+    "            \n",
+    "        return features.cpu().numpy()\n",
+    "    \n",
+    "    return np.array([])\n",
+    "\n",
     "def extract_features():\n",
-    "    \"\"\"Extract and save features for all ESC-50 audio files\"\"\"\n",
+    "    \"\"\"Extract and save features for all ESC-50 audio files using batch processing\"\"\"\n",
     "    \n",
     "    if os.path.exists('esc50_features.pkl'):\n",
     "        print(\"Features already extracted, loading from file...\")\n",
@@ -69,50 +125,30 @@
     "    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
     "    model.to(device)\n",
     "    \n",
-    "    # Load metadata\n",
+    "    # Create dataset\n",
     "    metadata_path = 'ESC-50/meta/esc50.csv'\n",
-    "    df = pd.read_csv(metadata_path)\n",
+    "    audio_dir = 'ESC-50/audio'\n",
+    "    dataset = ESC50Dataset(metadata_path, audio_dir)\n",
+    "    \n",
+    "    # Batch processing\n",
+    "    batch_size = 16\n",
+    "    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=False, num_workers=4)\n",
     "    \n",
     "    features_list = []\n",
     "    labels_list = []\n",
     "    folds_list = []\n",
     "    \n",
-    "    print(\"Extracting features...\")\n",
-    "    for idx, row in tqdm(df.iterrows(), total=len(df)):\n",
-    "        filename = row['filename']\n",
-    "        label = row['target']\n",
-    "        fold = row['fold']\n",
+    "    print(\"Extracting features with batch processing...\")\n",
+    "    for batch in tqdm(dataloader):\n",
+    "        audio_batch, label_batch, fold_batch = batch\n",
     "        \n",
-    "        audio_path = os.path.join('ESC-50/audio', filename)\n",
+    "        # Extract features for this batch\n",
+    "        batch_features = extract_features_batch(audio_batch, model, device)\n",
     "        \n",
-    "        try:\n",
-    "            # Load and preprocess audio\n",
-    "            audio, sr = librosa.load(audio_path, sr=16000)\n",
-    "            audio_tensor = torch.tensor(audio).float().unsqueeze(0).to(device)\n",
-    "            \n",
-    "            # Extract features\n",
-    "            with torch.no_grad(),torch.autocast(device_type='cuda'):\n",
-    "                features = model.encode(audio_tensor)\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\n",
-    "                if features.dim() > 2:\n",
-    "                    features = features.mean(dim=1)\n",
-    "                \n",
-    "                features = features.squeeze().cpu().numpy()\n",
-    "            \n",
-    "            features_list.append(features)\n",
-    "            labels_list.append(label)\n",
-    "            folds_list.append(fold)\n",
-    "            \n",
-    "        except Exception as e:\n",
-    "            print(f\"Error processing {filename}: {e}\")\n",
+    "        if len(batch_features) > 0:\n",
+    "            features_list.extend(batch_features)\n",
+    "            labels_list.extend(label_batch.numpy())\n",
+    "            folds_list.extend(fold_batch.numpy())\n",
     "    \n",
     "    # Save features\n",
     "    features_data = {\n",
@@ -126,15 +162,8 @@
     "        pickle.dump(features_data, f)\n",
     "    \n",
     "    print(f\"Features extracted: {len(features_list)} samples, embedding dim: {features_data['embedding_dim']}\")\n",
-    "    return features_data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
+    "    return features_data\n",
+    "\n",
     "# Download dataset and extract features\n",
     "download_esc50()\n",
     "features_data = extract_features()\n",
@@ -204,9 +233,10 @@
     "            batch_features = X_train_tensor[i:i+batch_size].to(device)\n",
     "            batch_labels = y_train_tensor[i:i+batch_size].to(device)\n",
     "            \n",
-    "            # Forward pass\n",
-    "            logits = classifier(batch_features)\n",
-    "            loss = criterion(logits, batch_labels)\n",
+    "            # Forward pass with autocast\n",
+    "            with torch.autocast(device_type='cuda' if device.type == 'cuda' else 'cpu'):\n",
+    "                logits = classifier(batch_features)\n",
+    "                loss = criterion(logits, batch_labels)\n",
     "            \n",
     "            # Backward pass\n",
     "            optimizer.zero_grad()\n",
@@ -222,7 +252,7 @@
     "        \n",
     "        # Validation\n",
     "        classifier.eval()\n",
-    "        with torch.no_grad():\n",
+    "        with torch.no_grad(), torch.autocast(device_type='cuda' if device.type == 'cuda' else 'cpu'):\n",
     "            val_features = X_val_tensor.to(device)\n",
     "            val_labels = y_val_tensor.cpu().numpy()\n",
     "            \n",