Upload 5 files

README.md

@@ -1,3 +1,90 @@
----
-license: mit
----
+# Mouse USV Detector - ProSAP1/Shank2 Male-Oestrus Female Interactions
+
+Deep learning model for detecting ultrasonic vocalizations (USVs) in mouse recordings from male-oestrus female social interactions.
+
+## Model Details
+
+- **Model Type**: Convolutional Neural Network (CNN)
+- **Task**: Binary classification (USV vs. noise)
+- **Architecture**: 4-layer CNN with batch normalization and dropout
+- **Parameters**: 10.4M
+- **Framework**: PyTorch 2.0+
+
+## Performance
+
+- **Validation Accuracy**: 96.0%
+- **Noise Detection**: 94.7%
+- **USV Detection**: 98.0%
+
+## Training Protocol
+
+- **Subject**: S2-4-65
+- **Strain**: ProSAP1/Shank2
+- **Behavior**: Male-oestrus female interactions (10 min + 3 min)
+- **Dataset**: 7,188 training samples, 2,146 validation samples
+- **Epochs**: 10
+
+## Audio Specifications
+
+- **Sample Rate**: 250 kHz (ultrasonic)
+- **USV Frequency Range**: 40-100 kHz
+- **Input Format**: 64x64 spectrogram patches
+
+## Usage
+
+```python
+import torch
+from model_architecture import load_model
+from inference_example import predict
+
+# Load model
+model = load_model('final_usv_model.pth')
+
+# Predict on audio file
+result = predict('audio.wav', model)
+print(f"USV: {result['is_usv']}, Confidence: {result['confidence']:.2%}")
+```
+
+## Requirements
+
+```bash
+pip install torch numpy librosa scipy
+```
+
+## Files
+
+- `final_usv_model.pth` - Trained model weights (41.9 MB)
+- `model_architecture.py` - CNN architecture definition
+- `inference_example.py` - Example inference code
+- `config.json` - Model configuration and metadata
+- `requirements.txt` - Python dependencies
+
+## Citation
+
+If you use this model, please cite:
+
+```bibtex
+@misc{usv_detector_prosap1_shank2,
+  title={Mouse USV Detector for ProSAP1/Shank2 Social Interactions},
+  author={Your Name},
+  year={2025},
+  publisher={Hugging Face},
+  howpublished={\url{https://huggingface.co/your-username/model-name}}
+}
+```
+
+## License
+
+[Specify your license here]
+
+## Methodology
+
+Based on the DeepSqueak methodology for USV detection:
+- Spectrogram-based feature extraction
+- Tonality calculation for USV identification
+- Automated detection with manual validation
+- Deep learning classification for robust detection
+
+## Contact
+
+[Your contact information]

config.json

@@ -0,0 +1,38 @@
+{
+  "model_name": "Mouse_USV_Detector_ProSAP1_Shank2",
+  "model_type": "USVDetectorCNN",
+  "task": "audio-classification",
+  "protocol": "S2-4-65 ProSAP1/Shank2 Male-Oestrus Female Interactions",
+  "architecture": {
+    "input_size": [64, 64],
+    "num_classes": 2,
+    "classes": ["noise", "usv"]
+  },
+  "audio_preprocessing": {
+    "sample_rate": 250000,
+    "nfft": 0.0032,
+    "overlap": 0.0028,
+    "hop_length_samples": 800,
+    "freq_range": [40000, 100000],
+    "freq_range_description": "Mouse USV frequency range (40-100 kHz)"
+  },
+  "training": {
+    "dataset_size": 9334,
+    "train_samples": 7188,
+    "val_samples": 2146,
+    "num_epochs": 10,
+    "batch_size": 32,
+    "learning_rate": 0.001,
+    "optimizer": "Adam",
+    "loss_function": "CrossEntropyLoss"
+  },
+  "performance": {
+    "validation_accuracy": 96.0,
+    "noise_accuracy": 94.7,
+    "usv_accuracy": 98.0
+  },
+  "framework": "pytorch",
+  "pytorch_version": "2.0+",
+  "model_size_mb": 41.9,
+  "parameters": 10467202
+}

inference_example.py

@@ -0,0 +1,84 @@
+import torch
+import numpy as np
+import librosa
+from scipy.ndimage import zoom
+from model_architecture import load_model
+
+def preprocess_audio(audio_path, sr=250000, nfft=0.0032, overlap=0.0028, 
+                     freq_range=(40000, 100000)):
+    '''
+    Preprocess audio file into spectrogram patch
+    
+    Args:
+        audio_path: Path to .wav file
+        sr: Sample rate (250 kHz for ultrasonic)
+        nfft: FFT window size in seconds
+        overlap: Overlap between windows in seconds
+        freq_range: Frequency range to extract (Hz)
+    
+    Returns:
+        torch.Tensor: Preprocessed spectrogram (1, 1, 64, 64)
+    '''
+    # Load audio
+    audio, _ = librosa.load(audio_path, sr=sr)
+    
+    # Generate spectrogram
+    nfft_samples = int(nfft * sr)
+    hop_length = int((nfft - overlap) * sr)
+    spec = librosa.stft(audio, n_fft=nfft_samples, hop_length=hop_length)
+    spec_db = librosa.amplitude_to_db(np.abs(spec), ref=np.max)
+    
+    # Filter to USV frequency range
+    freqs = librosa.fft_frequencies(sr=sr, n_fft=nfft_samples)
+    freq_mask = (freqs >= freq_range[0]) & (freqs <= freq_range[1])
+    spec_db = spec_db[freq_mask, :]
+    
+    # Resize to 64x64
+    zoom_factors = (64 / spec_db.shape[0], 64 / spec_db.shape[1])
+    spec_resized = zoom(spec_db, zoom_factors, order=1)
+    
+    # Normalize
+    spec_resized = (spec_resized - np.mean(spec_resized)) / (np.std(spec_resized) + 1e-8)
+    
+    # Convert to tensor
+    return torch.FloatTensor(spec_resized).unsqueeze(0).unsqueeze(0)
+
+def predict(audio_path, model):
+    '''
+    Predict if audio contains USV
+    
+    Args:
+        audio_path: Path to .wav file
+        model: Loaded USVDetectorCNN model
+    
+    Returns:
+        dict: Prediction results
+    '''
+    # Preprocess
+    spec_tensor = preprocess_audio(audio_path)
+    
+    # Predict
+    with torch.no_grad():
+        output = model(spec_tensor)
+        probabilities = torch.softmax(output, dim=1)
+        prediction = torch.argmax(output, dim=1).item()
+    
+    return {
+        'is_usv': prediction == 1,
+        'confidence': probabilities[0][prediction].item(),
+        'usv_probability': probabilities[0][1].item(),
+        'noise_probability': probabilities[0][0].item()
+    }
+
+# Example usage
+if __name__ == "__main__":
+    # Load model
+    model = load_model('final_usv_model.pth')
+    
+    # Predict
+    result = predict('test_audio.wav', model)
+    
+    print(f"USV Detected: {result['is_usv']}")
+    print(f"Confidence: {result['confidence']:.2%}")
+    print(f"USV Probability: {result['usv_probability']:.2%}")
+    print(f"Noise Probability: {result['noise_probability']:.2%}")

model_architecture.py

@@ -0,0 +1,67 @@
+import torch
+import torch.nn as nn
+
+class USVDetectorCNN(nn.Module):
+    '''
+    CNN for Mouse Ultrasonic Vocalization (USV) Detection
+    
+    Trained on ProSAP1/Shank2 male-oestrus female interaction recordings.
+    Classifies spectrogram patches as USV or noise.
+    
+    Input: (batch_size, 1, 64, 64) - Spectrogram patch in 40-100 kHz range
+    Output: (batch_size, 2) - Logits for [noise, usv]
+    '''
+    
+    def __init__(self, input_size=(64, 64), num_classes=2):
+        super().__init__()
+        
+        self.features = nn.Sequential(
+            nn.Conv2d(1, 64, kernel_size=3, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),
+            nn.Dropout2d(0.2),
+            
+            nn.Conv2d(64, 128, kernel_size=3, padding=1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),
+            nn.Dropout2d(0.2),
+            
+            nn.Conv2d(128, 256, kernel_size=3, padding=1),
+            nn.BatchNorm2d(256),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),
+            nn.Dropout2d(0.3),
+            
+            nn.Conv2d(256, 512, kernel_size=3, padding=1),
+            nn.BatchNorm2d(512),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),
+            nn.Dropout2d(0.3),
+        )
+        
+        flat_size = 512 * (input_size[0] // 16) * (input_size[1] // 16)
+        
+        self.classifier = nn.Sequential(
+            nn.Linear(flat_size, 1024),
+            nn.ReLU(inplace=True),
+            nn.Dropout(0.5),
+            nn.Linear(1024, 512),
+            nn.ReLU(inplace=True),
+            nn.Dropout(0.5),
+            nn.Linear(512, num_classes)
+        )
+    
+    def forward(self, x):
+        x = self.features(x)
+        x = x.view(x.size(0), -1)
+        x = self.classifier(x)
+        return x
+
+def load_model(model_path='final_usv_model.pth', device='cpu'):
+    '''Load the trained model'''
+    model = USVDetectorCNN(input_size=(64, 64), num_classes=2)
+    model.load_state_dict(torch.load(model_path, map_location=device))
+    model.eval()
+    return model

requirements.txt

@@ -0,0 +1,4 @@
+torch>=2.0.0
+numpy>=1.24.0
+librosa>=0.10.0
+scipy>=1.10.0