Add model with Gradio for Inference

.gitattributes

@@ -33,3 +33,4 @@ 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
+*.wav filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,35 @@
+import gradio as gr
+import tempfile
+from inference import AudioClassifier, Config  
+
+# Initialize config
+config = Config(
+    yamnet_model_path="yamnet/yamnet.h5",
+    yamnet_classes_path="yamnet/yamnet_class_map.csv",
+    model_path="model/model.h5",
+    custom_classes_path="model/model.npy",
+    output_dir="results",
+    output_file="classification.txt"
+)
+
+classifier = AudioClassifier(config)
+
+def classify_audio(audio_file):
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp:
+        temp.write(audio_file.read())
+        path = temp.name
+
+    result = classifier.classify_file(path)
+    label = result['dominant_label']
+    percent = result['dominant_score_percentage']
+    breakdown = "\n".join(f"{k}: {round(v*100)}%" for k, v in sorted(
+        result["aggregated_predictions"].items(), key=lambda x: x[1], reverse=True))
+    return f"🔊 **Top Prediction**: {label} ({percent}%)\n\n📊 **Top Classes**:\n{breakdown}"
+
+gr.Interface(
+    fn=classify_audio,
+    inputs=gr.Audio(type="file"),
+    outputs="markdown",
+    title="YAMNet + Custom Model Audio Classifier",
+    description="Upload a WAV file."
+).launch()

dataset_preprocess.py

@@ -0,0 +1,231 @@
+"""
+Audio Converter
+
+This script scans a directory for audio files and converts them to WAV format.
+It only processes audio files and skips all other file types.
+
+Usage:
+    python audio_converter.py --input_dir /path/to/audio/files --output_dir /path/to/output
+"""
+
+import os
+import sys
+import argparse
+from pathlib import Path
+from typing import List, Tuple
+import subprocess
+
+
+def print_info(message):
+    print(f"INFO: {message}")
+
+def print_error(message):
+    print(f"ERROR: {message}")
+
+def print_debug(message):
+    if VERBOSE:
+        print(f"DEBUG: {message}")
+
+VERBOSE = False
+
+# Audio formats that can be converted
+AUDIO_FORMATS = {
+    '.mp3', '.m4a', '.aac', '.flac', '.ogg', '.wma', '.aiff', '.ape', '.opus'
+}
+
+
+def check_dependencies() -> bool:
+    """
+    Check if required dependencies are installed.
+    
+    Returns:
+        bool: True if dependencies are met, False otherwise
+    """
+    # Check for ffmpeg
+    try:
+        subprocess.run(
+            ["ffmpeg", "-version"], 
+            stdout=subprocess.PIPE, 
+            stderr=subprocess.PIPE
+        )
+        print_info("ffmpeg is installed.")
+        return True
+    except FileNotFoundError:
+        print_error("ffmpeg is not installed. Please install it before running this script.")
+        return False
+
+
+def scan_directory(directory: str) -> Tuple[List[Path], List[Path]]:
+    """
+    Scan directory for audio files.
+    
+    Args:
+        directory: Path to the directory to scan
+        
+    Returns:
+        Tuple containing lists of audio files and files to skip
+    """
+    audio_files = []
+    skip_files = []
+    
+    dir_path = Path(directory)
+    if not dir_path.exists():
+        raise FileNotFoundError(f"Directory not found: {directory}")
+    
+    for file_path in dir_path.glob('**/*'):
+        if file_path.is_file():
+            file_ext = file_path.suffix.lower()
+            
+            if file_ext in AUDIO_FORMATS:
+                audio_files.append(file_path)
+            elif file_ext == '.wav':
+                # Skip existing WAV files
+                print_debug(f"Skipping existing WAV file: {file_path}")
+                skip_files.append(file_path)
+            else:
+                # Skip non-audio files
+                print_debug(f"Skipping non-audio file: {file_path}")
+                skip_files.append(file_path)
+    
+    print_info(f"Found {len(audio_files)} audio files to convert")
+    print_info(f"Skipping {len(skip_files)} files (WAV or non-audio)")
+    
+    return audio_files, skip_files
+
+
+def convert_audio_to_wav(input_file: Path, output_file: Path) -> bool:
+    """
+    Convert audio file to WAV format using ffmpeg.
+    
+    Args:
+        input_file: Path to input audio file
+        output_file: Path to output WAV file
+        
+    Returns:
+        bool: True if conversion was successful, False otherwise
+    """
+    try:
+        # Ensure output directory exists
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        
+        cmd = [
+            "ffmpeg",
+            "-y",  # Overwrite output file if it exists
+            "-i", str(input_file),  # Input file
+            "-acodec", "pcm_s16le",  # Output codec (16-bit PCM)
+            "-ar", "44100",  # Sample rate (44.1kHz)
+            "-ac", "1",  # Mono audio (1 channel)
+            str(output_file)  # Output file
+        ]
+        
+        process = subprocess.run(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+        
+        if process.returncode != 0:
+            print_error(f"Error converting {input_file}: {process.stderr.decode()}")
+            return False
+            
+        print_info(f"Successfully converted {input_file} to WAV")
+        return True
+        
+    except Exception as e:
+        print_error(f"Error converting {input_file}: {str(e)}")
+        return False
+
+
+def process_files(audio_files: List[Path], input_dir: str, output_dir: str, 
+                  preserve_structure: bool = True) -> Tuple[int, int]:
+    """
+    Process all identified audio files for conversion.
+    
+    Args:
+        audio_files: List of audio files to convert
+        input_dir: Input directory path 
+        output_dir: Output directory path
+
+    Returns:
+        Tuple of successful conversions, failed conversions
+    """
+    input_base = Path(input_dir)
+    output_base = Path(output_dir)
+    
+    success_count = 0
+    failure_count = 0
+    
+    # Process audio files
+    for audio_file in audio_files:
+        if preserve_structure:
+            rel_path = audio_file.relative_to(input_base)
+            output_file = output_base / rel_path.with_suffix('.wav')
+        else:
+          
+            output_file = output_base / f"{audio_file.stem}.wav"
+        
+        if convert_audio_to_wav(audio_file, output_file):
+            success_count += 1
+        else:
+            failure_count += 1
+    
+    return success_count, failure_count
+
+
+def parse_arguments() -> argparse.Namespace:
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(description="Convert audio files to WAV format")
+    parser.add_argument('--input_dir', type=str, required=True, 
+                        help='Directory containing files to convert')
+    parser.add_argument('--output_dir', type=str, required=True, 
+                        help='Directory for output WAV files')
+    parser.add_argument('--flat', action='store_true',
+                        help='Don\'t preserve directory structure')
+    parser.add_argument('--verbose', '-v', action='store_true',
+                        help='Enable verbose output')
+    
+    return parser.parse_args()
+
+
+def main():
+    """Main function to run the script."""
+    global VERBOSE
+    
+    try:
+        args = parse_arguments()
+        
+        VERBOSE = args.verbose
+        
+        print_info(f"Input directory: {args.input_dir}")
+        print_info(f"Output directory: {args.output_dir}")
+        
+        if not check_dependencies():
+            print_error("Missing dependencies. Please install required packages.")
+            sys.exit(1)
+        
+        # Create output directory if it doesn't exist
+        os.makedirs(args.output_dir, exist_ok=True)
+        
+        audio_files, skip_files = scan_directory(args.input_dir)
+        
+        # Process files
+        preserve_structure = not args.flat
+        success_count, failure_count = process_files(
+            audio_files, 
+            args.input_dir, 
+            args.output_dir, 
+            preserve_structure
+        )
+        
+        # Print summary
+        print_info(f"Conversion complete!")
+        print_info(f"Successfully converted: {success_count} files")
+        print_info(f"Failed conversions: {failure_count} files")
+        
+    except Exception as e:
+        print_error(f"Error during execution: {str(e)}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

features.py

@@ -0,0 +1,150 @@
+"""Feature computation for YAMNet."""
+
+import numpy as np
+import tensorflow as tf
+
+
+def waveform_to_log_mel_spectrogram_patches(waveform, params):
+  """Compute log mel spectrogram patches of a 1-D waveform."""
+  with tf.name_scope('log_mel_features'):
+    # waveform has shape [<# samples>]
+
+    # Convert waveform into spectrogram using a Short-Time Fourier Transform.
+    # Note that tf.signal.stft() uses a periodic Hann window by default.
+    window_length_samples = int(
+      round(params.sample_rate * params.stft_window_seconds))
+    hop_length_samples = int(
+      round(params.sample_rate * params.stft_hop_seconds))
+    fft_length = 2 ** int(np.ceil(np.log(window_length_samples) / np.log(2.0)))
+    num_spectrogram_bins = fft_length // 2 + 1
+    if params.tflite_compatible:
+      magnitude_spectrogram = _tflite_stft_magnitude(
+          signal=waveform,
+          frame_length=window_length_samples,
+          frame_step=hop_length_samples,
+          fft_length=fft_length)
+    else:
+      magnitude_spectrogram = tf.abs(tf.signal.stft(
+          signals=waveform,
+          frame_length=window_length_samples,
+          frame_step=hop_length_samples,
+          fft_length=fft_length))
+    # magnitude_spectrogram has shape [<# STFT frames>, num_spectrogram_bins]
+
+    # Convert spectrogram into log mel spectrogram.
+    linear_to_mel_weight_matrix = tf.signal.linear_to_mel_weight_matrix(
+        num_mel_bins=params.mel_bands,
+        num_spectrogram_bins=num_spectrogram_bins,
+        sample_rate=params.sample_rate,
+        lower_edge_hertz=params.mel_min_hz,
+        upper_edge_hertz=params.mel_max_hz)
+    mel_spectrogram = tf.matmul(
+      magnitude_spectrogram, linear_to_mel_weight_matrix)
+    log_mel_spectrogram = tf.math.log(mel_spectrogram + params.log_offset)
+    # log_mel_spectrogram has shape [<# STFT frames>, params.mel_bands]
+
+    # Frame spectrogram (shape [<# STFT frames>, params.mel_bands]) into patches
+    # (the input examples). Only complete frames are emitted, so if there is
+    # less than params.patch_window_seconds of waveform then nothing is emitted
+    # (to avoid this, zero-pad before processing).
+    spectrogram_hop_length_samples = int(
+      round(params.sample_rate * params.stft_hop_seconds))
+    spectrogram_sample_rate = params.sample_rate / spectrogram_hop_length_samples
+    patch_window_length_samples = int(
+      round(spectrogram_sample_rate * params.patch_window_seconds))
+    patch_hop_length_samples = int(
+      round(spectrogram_sample_rate * params.patch_hop_seconds))
+    features = tf.signal.frame(
+        signal=log_mel_spectrogram,
+        frame_length=patch_window_length_samples,
+        frame_step=patch_hop_length_samples,
+        axis=0)
+    # features has shape [<# patches>, <# STFT frames in an patch>, params.mel_bands]
+
+    return log_mel_spectrogram, features
+
+
+def pad_waveform(waveform, params):
+  """Pads waveform with silence if needed to get an integral number of patches."""
+  # In order to produce one patch of log mel spectrogram input to YAMNet, we
+  # need at least one patch window length of waveform plus enough extra samples
+  # to complete the final STFT analysis window.
+  min_waveform_seconds = (
+      params.patch_window_seconds +
+      params.stft_window_seconds - params.stft_hop_seconds)
+  min_num_samples = tf.cast(min_waveform_seconds * params.sample_rate, tf.int32)
+  num_samples = tf.shape(waveform)[0]
+  num_padding_samples = tf.maximum(0, min_num_samples - num_samples)
+
+  # In addition, there might be enough waveform for one or more additional
+  # patches formed by hopping forward. If there are more samples than one patch,
+  # round up to an integral number of hops.
+  num_samples = tf.maximum(num_samples, min_num_samples)
+  num_samples_after_first_patch = num_samples - min_num_samples
+  hop_samples = tf.cast(params.patch_hop_seconds * params.sample_rate, tf.int32)
+  num_hops_after_first_patch = tf.cast(tf.math.ceil(
+          tf.cast(num_samples_after_first_patch, tf.float32) /
+          tf.cast(hop_samples, tf.float32)), tf.int32)
+  num_padding_samples += (
+      hop_samples * num_hops_after_first_patch - num_samples_after_first_patch)
+
+  padded_waveform = tf.pad(waveform, [[0, num_padding_samples]],
+                           mode='CONSTANT', constant_values=0.0)
+  return padded_waveform
+
+
+def _tflite_stft_magnitude(signal, frame_length, frame_step, fft_length):
+  """TF-Lite-compatible version of tf.abs(tf.signal.stft())."""
+  def _hann_window():
+    return tf.reshape(
+      tf.constant(
+          (0.5 - 0.5 * np.cos(2 * np.pi * np.arange(0, 1.0, 1.0 / frame_length))
+          ).astype(np.float32),
+          name='hann_window'), [1, frame_length])
+
+  def _dft_matrix(dft_length):
+    """Calculate the full DFT matrix in NumPy."""
+    # See https://en.wikipedia.org/wiki/DFT_matrix
+    omega = (0 + 1j) * 2.0 * np.pi / float(dft_length)
+    # Don't include 1/sqrt(N) scaling, tf.signal.rfft doesn't apply it.
+    return np.exp(omega * np.outer(np.arange(dft_length), np.arange(dft_length)))
+
+  def _rdft(framed_signal, fft_length):
+    """Implement real-input Discrete Fourier Transform by matmul."""
+    # We are right-multiplying by the DFT matrix, and we are keeping only the
+    # first half ("positive frequencies").  So discard the second half of rows,
+    # but transpose the array for right-multiplication.  The DFT matrix is
+    # symmetric, so we could have done it more directly, but this reflects our
+    # intention better.
+    complex_dft_matrix_kept_values = _dft_matrix(fft_length)[:(
+        fft_length // 2 + 1), :].transpose()
+    real_dft_matrix = tf.constant(
+        np.real(complex_dft_matrix_kept_values).astype(np.float32),
+        name='real_dft_matrix')
+    imag_dft_matrix = tf.constant(
+        np.imag(complex_dft_matrix_kept_values).astype(np.float32),
+        name='imaginary_dft_matrix')
+    signal_frame_length = tf.shape(framed_signal)[-1]
+    half_pad = (fft_length - signal_frame_length) // 2
+    padded_frames = tf.pad(
+        framed_signal,
+        [
+            # Don't add any padding in the frame dimension.
+            [0, 0],
+            # Pad before and after the signal within each frame.
+            [half_pad, fft_length - signal_frame_length - half_pad]
+        ],
+        mode='CONSTANT',
+        constant_values=0.0)
+    real_stft = tf.matmul(padded_frames, real_dft_matrix)
+    imag_stft = tf.matmul(padded_frames, imag_dft_matrix)
+    return real_stft, imag_stft
+
+  def _complex_abs(real, imag):
+    return tf.sqrt(tf.add(real * real, imag * imag))
+
+  framed_signal = tf.signal.frame(signal, frame_length, frame_step)
+  windowed_signal = framed_signal * _hann_window()
+  real_stft, imag_stft = _rdft(windowed_signal, fft_length)
+  stft_magnitude = _complex_abs(real_stft, imag_stft)
+  return stft_magnitude

inference.py

@@ -0,0 +1,515 @@
+"""
+Audio Classification using YAMNet and Custom Models
+A streamlined tool for classifying audio using pre-trained and custom models.
+"""
+
+import os
+import argparse
+import logging
+from pathlib import Path
+from typing import Dict, List, Tuple, Optional, Union, Any
+from dataclasses import dataclass, field
+
+import numpy as np
+import pandas as pd
+import librosa
+import resampy
+import soundfile as sf
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Suppress TensorFlow warnings
+tf.get_logger().setLevel(logging.ERROR)
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+
+
+@dataclass(frozen=True)
+class YAMNetParams:
+    """Parameters for YAMNet model."""
+    sample_rate: float = 16000.0
+    stft_window_seconds: float = 0.025
+    stft_hop_seconds: float = 0.010
+    mel_bands: int = 64
+    mel_min_hz: float = 125.0
+    mel_max_hz: float = 7500.0
+    log_offset: float = 0.001
+    patch_window_seconds: float = 0.96
+    patch_hop_seconds: float = 0.48
+    num_classes: int = 521
+    conv_padding: str = 'same'
+    batchnorm_center: bool = True
+    batchnorm_scale: bool = False
+    batchnorm_epsilon: float = 1e-4
+    classifier_activation: str = 'sigmoid'
+    tflite_compatible: bool = True
+
+    @property
+    def patch_frames(self) -> int:
+        """Calculate number of frames per patch."""
+        return int(round(self.patch_window_seconds / self.stft_hop_seconds))
+
+    @property
+    def patch_bands(self) -> int:
+        """Get number of mel bands."""
+        return self.mel_bands
+
+
+@dataclass
+class Config:
+    """Configuration for models and processing parameters."""
+
+    yamnet_model_path: str
+    yamnet_classes_path: str
+    model_path: Optional[str] = None
+    custom_classes_path: Optional[str] = None
+    output_dir: str = "results"
+    output_file: str = "classification.txt"
+    
+    # Processing parameters
+    window_length: int = 10  # seconds
+    hop_length: int = 1  # seconds
+    custom_weight_factor: float = 5.0
+    top_k: int = 10  # Number of top predictions to keep
+    
+    # Exclude certain classes
+    excluded_classes: List[str] = field(default_factory=lambda: ["Vehicle"])
+    
+    def __post_init__(self):
+        """Convert paths to absolute paths and ensure output directory exists."""
+        self.yamnet_model_path = os.path.abspath(self.yamnet_model_path)
+        self.yamnet_classes_path = os.path.abspath(self.yamnet_classes_path)
+        
+        if self.model_path:
+            self.model_path = os.path.abspath(self.model_path)
+        
+        if self.custom_classes_path:
+            self.custom_classes_path = os.path.abspath(self.custom_classes_path)
+        
+        # Create output directory
+        os.makedirs(Path(self.output_dir), exist_ok=True)
+    
+    @property
+    def output_path(self) -> str:
+        """Get full path to output file."""
+        return os.path.join(self.output_dir, self.output_file)
+
+    @classmethod
+    def from_args(cls, args: argparse.Namespace) -> 'Config':
+        """Create config from command line arguments."""
+        output_dir = os.path.dirname(args.output) or "results"
+        output_file = os.path.basename(args.output) or "classification.txt"
+        
+        return cls(
+            yamnet_model_path=args.yamnet_model,
+            yamnet_classes_path=args.yamnet_classes,
+            model_path=args.model if os.path.exists(args.model) else None,
+            custom_classes_path=args.custom_classes if os.path.exists(args.custom_classes) else None,
+            output_dir=output_dir,
+            output_file=output_file,
+            window_length=args.window,
+            hop_length=args.hop,
+            custom_weight_factor=args.weight
+        )
+
+
+class AudioClassifier:
+    """Audio classification using YAMNet and custom models."""
+    
+    def __init__(self, config: Config):
+        """Initialize classifier with configuration."""
+        self.config = config
+        self.params = YAMNetParams()
+        
+        # Initialize models
+        self.yamnet_model = None
+        self.model = None
+        self.yamnet_classes = []
+        self.custom_classes = []
+        
+        # Load models
+        self._load_models()
+    
+    def _load_models(self) -> None:
+        """Load YAMNet and custom models."""
+        # Load YAMNet model
+        try:
+            from yamnet import yamnet_frames_model, class_names
+            
+            logger.info(f"Loading YAMNet model from {self.config.yamnet_model_path}")
+            self.yamnet_model = yamnet_frames_model(self.params)
+            self.yamnet_model.load_weights(self.config.yamnet_model_path)
+            
+            logger.info(f"Loading YAMNet classes from {self.config.yamnet_classes_path}")
+            self.yamnet_classes = class_names(self.config.yamnet_classes_path)
+            
+        except ImportError:
+            logger.error("YAMNet module not found. Please install it or provide correct path.")
+            raise
+        except Exception as e:
+            logger.error(f"Failed to load YAMNet model: {e}")
+            raise
+        
+        # Load custom model if available
+        if self.config.model_path:
+            try:
+                logger.info(f"Loading custom model from {self.config.model_path}")
+                self.model = load_model(self.config.model_path)
+                
+                if self.config.custom_classes_path:
+                    logger.info(f"Loading custom classes from {self.config.custom_classes_path}")
+                    self.custom_classes = np.load(self.config.custom_classes_path, allow_pickle=True)
+                
+            except Exception as e:
+                logger.warning(f"Failed to load custom model: {e}")
+                logger.warning("Continuing with YAMNet model only.")
+                self.model = None
+                self.custom_classes = []
+    
+    def classify_file(self, audio_path: str) -> Dict[str, Any]:
+        """Classify audio file and return results."""
+        logger.info(f"Processing audio file: {audio_path}")
+        
+        # Load audio
+        waveform, sr = self._load_audio(audio_path)
+        
+        # Process audio segments
+        logger.info("Processing audio segments...")
+        segments_results = self._process_audio_segments(waveform, sr)
+        
+        # Aggregate results
+        logger.info("Aggregating results...")
+        final_results = self._aggregate_results(segments_results)
+        
+        # Save results
+        if self.config.output_path:
+            self._save_results(final_results)
+        
+        return final_results
+    
+    def _load_audio(self, file_path: str) -> Tuple[np.ndarray, int]:
+        """Load and preprocess audio file."""
+      
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"Audio file not found: {file_path}")
+            
+        # Load audio data
+        logger.info(f"Loading audio from {file_path}")
+        wav_data, sr = sf.read(file_path, dtype=np.int16)
+        
+        # Convert to float32 in range [-1.0, 1.0]
+        waveform = wav_data / 32768.0
+        waveform = waveform.astype('float32')
+        
+        # Convert stereo to mono if needed
+        if len(waveform.shape) > 1:
+            logger.info("Converting stereo audio to mono")
+            waveform = np.mean(waveform, axis=1)
+        
+        # Resample if needed
+        if sr != self.params.sample_rate:
+            logger.info(f"Resampling audio from {sr}Hz to {self.params.sample_rate}Hz")
+            waveform = resampy.resample(waveform, sr, self.params.sample_rate)
+            sr = int(self.params.sample_rate)
+        
+        return waveform, sr
+    
+    def _process_audio_segments(self, waveform: np.ndarray, sr: int) -> List[Dict[str, Any]]:
+        """Process audio in segments."""
+        segment_length_samples = int(sr * self.config.window_length)
+        hop_length_samples = int(sr * self.config.hop_length)
+        
+        if segment_length_samples <= 0:
+            raise ValueError(f"Invalid segment length: {self.config.window_length} seconds")
+        
+        segments_results = []
+        
+        # Process each segment
+        total_segments = max(1, (len(waveform) - segment_length_samples + hop_length_samples) // hop_length_samples)
+        for i in range(0, len(waveform) - segment_length_samples + 1, hop_length_samples):
+            segment_idx = i // hop_length_samples + 1
+            logger.debug(f"Processing segment {segment_idx}/{total_segments}")
+            
+            end_idx = min(i + segment_length_samples, len(waveform))
+            window = waveform[i:end_idx]
+            
+            # Get YAMNet predictions
+            yamnet_predictions = self._get_yamnet_predictions(window)
+            
+            # Get custom model predictions if available
+            custom_predictions = None
+            if self.model is not None:
+                custom_predictions = self._get_custom_predictions(window)
+            
+            # Combine predictions
+            combined_results = self._combine_predictions(yamnet_predictions, custom_predictions)
+            
+            # Store results
+            segment_result = {
+                'yamnet_predictions': yamnet_predictions,
+                'custom_predictions': custom_predictions,
+                'combined_predictions': combined_results
+            }
+            
+            segments_results.append(segment_result)
+        
+        return segments_results
+    
+    def _get_yamnet_predictions(self, audio_segment: np.ndarray) -> Dict[str, float]:
+        """Get YAMNet predictions for an audio segment."""
+        try:
+            scores, embeddings, spectrogram = self.yamnet_model(audio_segment)
+            prediction = np.mean(scores, axis=0)
+            
+            # Get top predictions
+            top_indices = np.argsort(prediction)[::-1][:self.config.top_k]
+            top_labels = [self.yamnet_classes[i] for i in top_indices]
+            top_scores = prediction[top_indices]
+            
+            return {label: float(score) for label, score in zip(top_labels, top_scores)}
+            
+        except Exception as e:
+            logger.error(f"Error in YAMNet prediction: {e}")
+            return {}
+    
+    def _get_custom_predictions(self, audio_segment: np.ndarray) -> Dict[str, float]:
+        """Get custom model predictions for an audio segment."""
+        try:
+            # Get YAMNet embeddings first
+            embeddings = self.yamnet_model(audio_segment)[1]
+            
+            # Reshape embeddings for custom model
+            embeddings_reshaped = np.reshape(embeddings, (embeddings.shape[0], -1))
+            
+            # Get predictions from custom model
+            predictions = self.model.predict(embeddings_reshaped, verbose=0)
+            
+            # Calculate mean prediction over time
+            mean_predictions = np.mean(predictions, axis=0)
+            
+            # Get top predictions
+            top_indices = np.argsort(mean_predictions)[::-1][:self.config.top_k]
+            
+            # Check if custom classes are available
+            if len(self.custom_classes) > 0:
+                top_labels = [self.custom_classes[i] for i in top_indices]
+            else:
+                # Use numeric indices as labels if no class names are available
+                top_labels = [f"Class_{i}" for i in top_indices]
+                
+            top_scores = mean_predictions[top_indices]
+            
+            # Normalize scores
+            total_score = np.sum(top_scores)
+            if total_score > 0:
+                top_scores = top_scores / total_score
+            
+            return {label: float(score) for label, score in zip(top_labels, top_scores)}
+            
+        except Exception as e:
+            logger.error(f"Error in custom model prediction: {e}")
+            return {}
+    
+    def _combine_predictions(
+        self, 
+        yamnet_predictions: Dict[str, float], 
+        custom_predictions: Optional[Dict[str, float]]
+    ) -> Dict[str, float]:
+        """Combine predictions from different models."""
+        combined = {}
+        
+        # Add custom predictions with weighting 
+        if custom_predictions:
+            for label, score in custom_predictions.items():
+                combined[label] = score * self.config.custom_weight_factor
+        
+        # Add YAMNet predictions if not already present or if higher score
+        for label, score in yamnet_predictions.items():
+            if label not in self.config.excluded_classes:
+                if label not in combined or score > combined[label]:
+                    combined[label] = score
+        
+        return combined
+    
+    def _aggregate_results(self, segments_results: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Aggregate results across all segments."""
+        # Initialize aggregated predictions
+        aggregated_predictions = {}
+        
+        # Collect all combined predictions, keeping maximum score per label
+        for segment in segments_results:
+            for label, score in segment['combined_predictions'].items():
+                if label in aggregated_predictions:
+                    aggregated_predictions[label] = max(aggregated_predictions[label], score)
+                else:
+                    aggregated_predictions[label] = score
+        
+        # Process results
+        if aggregated_predictions:
+            # Get top predictions
+            sorted_predictions = sorted(
+                aggregated_predictions.items(),
+                key=lambda x: x[1],
+                reverse=True
+            )[:self.config.top_k]
+            
+            # Create a new dictionary with only the top predictions
+            top_predictions = {label: score for label, score in sorted_predictions}
+            
+            # Normalize scores
+            total_score = sum(top_predictions.values())
+            if total_score > 0:
+                normalized_predictions = {
+                    label: score / total_score 
+                    for label, score in top_predictions.items()
+                }
+            else:
+                # Default to equal probabilities if all scores are 0
+                normalized_predictions = {
+                    label: 1.0 / len(top_predictions) if len(top_predictions) > 0 else 0.0
+                    for label in top_predictions
+                }
+            
+            # Find dominant label
+            dominant_label, dominant_score = max(normalized_predictions.items(), key=lambda x: x[1])
+            dominant_score_percentage = round(dominant_score * 100)
+            
+            # Replace original predictions with normalized ones
+            aggregated_predictions = normalized_predictions
+        else:
+            dominant_label = "Unknown"
+            dominant_score = 0
+            dominant_score_percentage = 0
+        
+        return {
+            'aggregated_predictions': aggregated_predictions,
+            'dominant_label': dominant_label,
+            'dominant_score': dominant_score,
+            'dominant_score_percentage': dominant_score_percentage
+        }
+    
+    def _save_results(self, results: Dict[str, Any]) -> None:
+        """Save classification results to file."""
+        try:
+            with open(self.config.output_path, 'w') as file:
+                file.write("Audio Classification Results\n")
+                file.write("=========================\n\n")
+                file.write(f"Primary Classification: {results['dominant_label']} ({results['dominant_score_percentage']}%)\n\n")
+                
+                # Add detailed breakdown
+                file.write("Classification Details:\n")
+                file.write("-----------------\n")
+                sorted_predictions = sorted(
+                    results['aggregated_predictions'].items(), 
+                    key=lambda x: x[1], 
+                    reverse=True
+                )
+                
+                for label, score in sorted_predictions:
+                    percentage = round(score * 100)
+                    file.write(f"{label}: {percentage}%\n")
+                
+            logger.info(f"Results saved to {self.config.output_path}")
+            
+        except Exception as e:
+            logger.error(f"Error saving results: {e}")
+            raise
+
+
+def main():
+    """Main function to run audio classification."""
+    parser = argparse.ArgumentParser(
+        description='Audio classification using YAMNet and custom models',
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    
+    # Required arguments
+    parser.add_argument('audio_file', type=str, help='Path to audio file for classification')
+    
+    # Model paths
+    parser.add_argument('--yamnet_model', type=str, default='yamnet/yamnet.h5', 
+                        help='Path to YAMNet model weights')
+    parser.add_argument('--yamnet_classes', type=str, default='yamnet/yamnet_class_map.csv', 
+                        help='Path to YAMNet class names')
+    parser.add_argument('--model', type=str, default='model/model.h5', 
+                        help='Path to custom model (optional)')
+    parser.add_argument('--custom_classes', type=str, default='model/model.npy', 
+                        help='Path to custom class names (optional)')
+    
+    # Processing parameters
+    parser.add_argument('--window', type=int, default=10, 
+                        help='Window length in seconds')
+    parser.add_argument('--hop', type=int, default=1, 
+                        help='Hop length in seconds')
+    parser.add_argument('--weight', type=float, default=5.0,
+                        help='Weighting factor for custom model predictions')
+    
+    # Output options
+    parser.add_argument('--output', type=str, default='results/classification.txt', 
+                        help='Path to output file')
+    
+    # Logging options
+    parser.add_argument('--verbose', action='store_true', 
+                        help='Enable verbose output')
+    parser.add_argument('--debug', action='store_true', 
+                        help='Enable debug logging')
+    
+    args = parser.parse_args()
+    
+    # Configure logging
+    if args.debug:
+        logger.setLevel(logging.DEBUG)
+    elif args.verbose:
+        logger.setLevel(logging.INFO)
+    else:
+        logger.setLevel(logging.WARNING)
+    
+    try:
+        # Create configuration
+        config = Config.from_args(args)
+        
+        # Create classifier
+        classifier = AudioClassifier(config)
+        
+        # Process audio file
+        results = classifier.classify_file(args.audio_file)
+        
+        # Print results
+        print("\nAudio Classification Results")
+        print("=========================")
+        print(f"\nPrimary Classification: {results['dominant_label']} ({results['dominant_score_percentage']}%)")
+        
+        if args.verbose:
+            print("\nTop 10 Predictions:")
+            print("-----------------")
+            sorted_predictions = sorted(
+                results['aggregated_predictions'].items(),
+                key=lambda x: x[1],
+                reverse=True
+            )
+            
+            for label, score in sorted_predictions:
+                percentage = round(score * 100)
+                print(f"{label}: {percentage}%")
+                
+        print(f"\nFull results saved to: {config.output_path}")
+        
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        if args.debug:
+            import traceback
+            traceback.print_exc()
+        return 1
+    
+    return 0
+
+
+if __name__ == '__main__':
+    import sys
+    sys.exit(main())

model/model.h5

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

model/model.npy

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

params.py

@@ -0,0 +1,36 @@
+"""Hyperparameters for YAMNet."""
+
+from dataclasses import dataclass
+
+# The following hyperparameters (except patch_hop_seconds) were used to train YAMNet,
+# so expect some variability in performance if you change these. The patch hop can
+# be changed arbitrarily: a smaller hop should give you more patches from the same
+# clip and possibly better performance at a larger computational cost.
+@dataclass(frozen=True)  # Instances of this class are immutable.
+class Params:
+  sample_rate: float = 16000.0
+  stft_window_seconds: float = 0.025
+  stft_hop_seconds: float = 0.010
+  mel_bands: int = 64
+  mel_min_hz: float = 125.0
+  mel_max_hz: float = 7500.0
+  log_offset: float = 0.001
+  patch_window_seconds: float = 0.96
+  patch_hop_seconds: float = 0.48
+
+  @property
+  def patch_frames(self):
+    return int(round(self.patch_window_seconds / self.stft_hop_seconds))
+
+  @property
+  def patch_bands(self):
+    return self.mel_bands
+
+  num_classes: int = 521
+  conv_padding: str = 'same'
+  batchnorm_center: bool = True
+  batchnorm_scale: bool = False
+  batchnorm_epsilon: float = 1e-4
+  classifier_activation: str = 'sigmoid'
+
+  tflite_compatible: bool = True

requirements.txt

@@ -0,0 +1,6 @@
+librosa==0.11.0
+numpy==1.26.4
+pandas==2.2.3
+tensorflow==2.9.0
+resampy==0.4.3
+ffmpeg

train.py

@@ -0,0 +1,514 @@
+"""
+Audio Classification System
+
+This module trains a neural network model on audio data using YAMNet embeddings.
+It extracts features from audio files and trains a classifier to recognize audio classes.
+
+Usage: 
+    python main.py --data_path <path_to_data> --model_name <model_name>
+    
+"""
+
+import os
+import sys
+import argparse
+import logging
+from pathlib import Path
+from typing import Tuple, List, Dict, Optional, Any
+
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+import librosa
+from tqdm import tqdm
+from sklearn.preprocessing import LabelBinarizer
+from sklearn.utils import shuffle
+
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler() 
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# Default configuration
+DEFAULT_CONFIG = {
+    'yamnet_path': 'yamnet/yamnet.h5',
+    'classes_path': 'yamnet/yamnet_class_map.csv',
+    'sample_rate': 16000,
+    'epochs': 100,
+    'batch_size': 32,
+    'learning_rate': 0.001,
+    'num_hidden': 1024,
+    'hidden_layer_size': 512,
+    'num_extra_layers': 1,
+    'dropout_rate': 0.3,
+    'regularization': 0.01,
+    'patience': 10,
+    'validation_split': 0.2,
+    'model_folder': 'model' 
+}
+
+
+class Configuration:
+    """Handles configuration for the audio classification system."""
+    
+    def __init__(self, custom_config: Optional[Dict[str, Any]] = None):
+        """
+        Initialize configuration handler.
+        
+        Args:
+            custom_config: Custom configuration to override defaults
+        """
+        self.config = DEFAULT_CONFIG.copy()
+        if custom_config:
+            self.config.update(custom_config)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self.config.get(key, default)
+    
+    def set(self, key: str, value: Any) -> None:
+        self.config[key] = value
+    
+    def __getitem__(self, key: str) -> Any:
+        return self.config[key]
+
+
+class ClassMap:
+    """Handles audio class mapping and persistence."""
+    
+    def __init__(self, config: Configuration):
+        """
+        Initialize class map.
+        
+        Args:
+            config: Configuration handler
+        """
+        self.config = config
+        self.classes_path = config['classes_path']
+        self._ensure_classes_file_exists()
+    
+    def _ensure_classes_file_exists(self) -> None:
+        """Ensure the classes mapping file exists."""
+        if not os.path.exists(self.classes_path):
+            logger.info(f"Class map file not found: {self.classes_path}. Creating a new one.")
+ 
+            pd.DataFrame({"display_name": [], "index": [], "mid": []}).to_csv(
+                self.classes_path, index=False
+            )
+    
+    def load_yamnet_classes(self) -> np.ndarray:
+        """Load classes from YAMNet class map CSV file."""
+        try:
+            df = pd.read_csv(self.classes_path)
+            return df["display_name"].values
+        except Exception as e:
+            logger.error(f"Error loading classes: {str(e)}")
+            return np.array([])
+    
+    def update_classes(self, data_path: str) -> List[str]:
+        """
+        Update classes based on directory structure.
+        
+        Args:
+            data_path: Path to data directory
+            
+        Returns:
+            List of all class names
+        """
+        try:
+            # Load existing classes mapping
+            existing_classes_df = pd.read_csv(self.classes_path)
+            existing_classes_set = set(existing_classes_df['display_name'])
+            
+            # Find new classes
+            new_classes = []
+            for cls in sorted(os.listdir(data_path)):
+                class_path = os.path.join(data_path, cls)
+                if os.path.isdir(class_path) and cls not in existing_classes_set:
+                    new_classes.append(cls)
+            
+            # Append new classes to the existing classes dataframe
+            if new_classes:
+                logger.info(f"Adding {len(new_classes)} new classes: {', '.join(new_classes)}")
+                new_classes_df = pd.DataFrame({
+                    'display_name': new_classes, 
+                    'index': [''] * len(new_classes), 
+                    'mid': [''] * len(new_classes)
+                })
+                updated_classes_df = pd.concat([existing_classes_df, new_classes_df], ignore_index=True)
+                updated_classes_df.to_csv(self.classes_path, index=False)
+                
+            # Return all classes from data directory
+            return [cls for cls in sorted(os.listdir(data_path)) 
+                    if os.path.isdir(os.path.join(data_path, cls))]
+            
+        except Exception as e:
+            logger.error(f"Error updating classes: {str(e)}")
+            raise
+
+
+class FeatureExtractor:
+    """Extracts features from audio files using YAMNet."""
+    
+    def __init__(self, config: Configuration):
+        """
+        Initialize feature extractor.
+        
+        Args:
+            config: Configuration handler
+        """
+        self.config = config
+        self.yamnet_model = self._load_yamnet_model()
+    
+    def _load_yamnet_model(self):
+        """Load YAMNet model for feature extraction."""
+        try:
+            logger.info("Loading YAMNet model...")
+            # Import here to avoid circular imports
+            from yamnet import yamnet_frames_model
+            from params import Params
+            
+            model = yamnet_frames_model(Params())
+            model.load_weights(self.config['yamnet_path'])
+            return model
+        except Exception as e:
+            logger.error(f"Error loading YAMNet model: {str(e)}")
+            raise
+    
+    def extract_features(self, audio_path: str) -> np.ndarray:
+        """
+        Extract features from an audio file using YAMNet.
+        
+        Args:
+            audio_path: Path to audio file
+            
+        Returns:
+            Numpy array of extracted features
+        """
+        try:
+            # Load audio file
+            wav, _ = librosa.load(
+                audio_path, 
+                sr=self.config['sample_rate'], 
+                mono=True
+            )
+            wav = wav.astype(np.float32)
+            
+            if len(wav) == 0:
+                logger.warning(f"Warning: Empty audio file: {audio_path}")
+                return np.array([])
+            
+            # Extract embeddings using YAMNet
+            _, embeddings, _ = self.yamnet_model(wav)
+            return embeddings.numpy()
+            
+        except Exception as e:
+            logger.error(f"Error extracting features from {audio_path}: {str(e)}")
+            return np.array([])
+
+
+class DatasetLoader:
+    """Creates a dataset from audio files."""
+    
+    def __init__(self, config: Configuration, feature_extractor: FeatureExtractor):
+        """
+        Initialize dataset creator.
+        
+        Args:
+            config: Configuration handler
+            feature_extractor: Feature extractor
+        """
+        self.config = config
+        self.feature_extractor = feature_extractor
+    
+    def create_dataset(self, data_path: str, classes: List[str]) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Create a dataset from audio files in the specified path.
+        
+        Args:
+            data_path: Path to the directory containing audio files organized in class folders
+            classes: List of class names
+            
+        Returns:
+            samples: Numpy array of audio features
+            labels: Numpy array of corresponding labels
+        """
+        samples, labels = [], []
+        
+        for cls in classes:
+            class_path = os.path.join(data_path, cls)
+            if not os.path.isdir(class_path):
+                continue
+                
+            logger.info(f"Processing class: {cls}")
+            audio_files = os.listdir(class_path)
+            
+            for sound in tqdm(audio_files, desc=f"Processing {cls}"):
+                audio_path = os.path.join(class_path, sound)
+                embeddings = self.feature_extractor.extract_features(audio_path)
+                
+                if len(embeddings) == 0:
+                    continue
+                
+                # Store each embedding frame with its label
+                for embedding in embeddings:
+                    samples.append(embedding)
+                    labels.append(cls)
+        
+        # Convert to numpy arrays
+        if not samples:
+            error_msg = "No valid audio samples were processed!"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+            
+        samples = np.asarray(samples)
+        labels = np.asarray(labels)
+        
+        logger.info(f"Created dataset with {len(samples)} samples across {len(set(labels))} classes")
+        return samples, labels
+
+
+class ModelBuilder:
+    """Builds and trains neural network models for audio classification."""
+    
+    def __init__(self, config: Configuration):
+        """
+        Initialize model builder.
+        
+        Args:
+            config: Configuration handler
+        """
+        self.config = config
+    
+    def build_model(self, num_classes: int) -> tf.keras.Model:
+        """
+        Build a neural network model for audio classification.
+        
+        Args:
+            num_classes: Number of output classes
+            
+        Returns:
+            Keras Model object
+        """
+        # Input layer (YAMNet embeddings are 1024-dimensional)
+        inputs = tf.keras.layers.Input(shape=(1024,))
+        
+        # First hidden layer with L2 regularization
+        x = tf.keras.layers.Dense(
+            self.config['num_hidden'], 
+            activation='relu',
+            kernel_regularizer=tf.keras.regularizers.l2(self.config['regularization'])
+        )(inputs)
+        x = tf.keras.layers.BatchNormalization()(x)
+        x = tf.keras.layers.Dropout(self.config['dropout_rate'])(x)
+        
+        # Additional hidden layers
+        for i in range(self.config['num_extra_layers']):
+            layer_size = self.config['hidden_layer_size'] // (i+1)
+            x = tf.keras.layers.Dense(
+                layer_size, 
+                activation='relu',
+                kernel_regularizer=tf.keras.regularizers.l2(self.config['regularization'])
+            )(x)
+            x = tf.keras.layers.BatchNormalization()(x)
+            x = tf.keras.layers.Dropout(self.config['dropout_rate'])(x)
+        
+        # Output layer
+        outputs = tf.keras.layers.Dense(num_classes, activation='softmax')(x)
+        
+        # Create and return model
+        model = tf.keras.Model(inputs=inputs, outputs=outputs)
+        return model
+    
+    def _create_callbacks(self, model_path: str) -> List[tf.keras.callbacks.Callback]:
+        """
+        Create callbacks for model training.
+        
+        Args:
+            model_path: Path to save the model
+            
+        Returns:
+            List of callbacks
+        """
+        # Create tensorboard callback
+        log_dir = Path(f"logs/{os.path.basename(model_path)}")
+        log_dir.mkdir(parents=True, exist_ok=True)
+        
+        tensorboard = tf.keras.callbacks.TensorBoard(
+            log_dir=log_dir,
+            histogram_freq=1
+        )
+        
+        # Early stopping callback
+        early_stopping = tf.keras.callbacks.EarlyStopping(
+            monitor='val_accuracy',
+            patience=self.config['patience'],
+            restore_best_weights=True,
+            verbose=1
+        )
+        
+        # Learning rate reduction callback
+        reduce_lr = tf.keras.callbacks.ReduceLROnPlateau(
+            monitor='val_loss',
+            factor=0.5,
+            patience=5,
+            min_lr=0.00001,
+            verbose=1
+        )
+        
+        return [early_stopping, reduce_lr, tensorboard]
+    
+    def train_model(self, X: np.ndarray, y: np.ndarray, model_name: str) -> Tuple[tf.keras.Model, LabelBinarizer]:
+        """
+        Train a model on the provided data.
+        
+        Args:
+            X: Input features
+            y: Target labels
+            model_name: Name of the model
+            
+        Returns:
+            Tuple of (trained model, label encoder)
+        """
+        # Encode the labels (one-hot encoding)
+        encoder = LabelBinarizer()
+        encoded_labels = encoder.fit_transform(y)
+        num_classes = len(encoder.classes_)
+        
+        logger.info(f"Training model with {num_classes} classes: {', '.join(encoder.classes_)}")
+        
+        # Create model
+        model = self.build_model(num_classes=num_classes)
+        
+        # Print model summary
+        model.summary()
+        
+        # Compile model
+        optimizer = tf.keras.optimizers.Adam(learning_rate=self.config['learning_rate'])
+        model.compile(
+            optimizer=optimizer,
+            loss=tf.keras.losses.CategoricalCrossentropy(),
+            metrics=['accuracy']
+        )
+        
+        model_folder = os.path.join(self.config['model_folder'])
+        os.makedirs(model_folder, exist_ok=True)
+       
+        model_path = os.path.join(model_folder, model_name)
+        
+        callbacks = self._create_callbacks(model_path)
+        
+        # Train the model
+        history = model.fit(
+            X, encoded_labels,
+            epochs=self.config['epochs'],
+            batch_size=self.config['batch_size'],
+            validation_split=self.config['validation_split'],
+            callbacks=callbacks,
+            verbose=1
+        )
+        
+        # Save the model and class names
+        model.save(f"{model_path}.h5")
+        np.save(f"{model_path}_classes.npy", encoder.classes_)
+        
+        # Save training history
+        hist_df = pd.DataFrame(history.history)
+        hist_df.to_csv(f"{model_path}_history.csv", index=False)
+        
+        logger.info(f"Model saved as {model_path}.h5")
+        logger.info(f"Class names saved as {model_path}_classes.npy")
+        
+        return model, encoder
+
+
+def parse_arguments() -> argparse.Namespace:
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(description="Train an audio classification model")
+    parser.add_argument('--data_path', type=str, required=True, 
+                        help='Path to the directory containing audio files')
+    parser.add_argument('--model_name', type=str, required=True, 
+                        help='Name for the saved model')
+    parser.add_argument('--config', type=str, 
+                        help='Path to config JSON file (optional)')
+    parser.add_argument('--epochs', type=int, default=DEFAULT_CONFIG['epochs'],
+                        help='Number of training epochs')
+    parser.add_argument('--batch_size', type=int, default=DEFAULT_CONFIG['batch_size'],
+                        help='Batch size for training')
+    parser.add_argument('--learning_rate', type=float, default=DEFAULT_CONFIG['learning_rate'],
+                        help='Initial learning rate')
+    parser.add_argument('--model_folder', type=str, default=DEFAULT_CONFIG['model_folder'],
+                        help='Folder to save the model')
+    
+    return parser.parse_args()
+
+
+def load_custom_config(config_path: Optional[str]) -> Dict[str, Any]:
+    """Load custom configuration from a JSON file."""
+    if not config_path:
+        return {}
+    
+    try:
+        import json
+        with open(config_path, 'r') as f:
+            return json.load(f)
+    except Exception as e:
+        logger.error(f"Error loading config file: {str(e)}")
+        return {}
+
+
+def main():
+    """Main function to run the script."""
+    try:
+     
+        args = parse_arguments()
+        
+        # Load custom configuration
+        custom_config = load_custom_config(args.config)
+        
+
+        custom_config.update({
+            'epochs': args.epochs,
+            'batch_size': args.batch_size,
+            'learning_rate': args.learning_rate,
+            'model_folder': args.model_folder
+        })
+        
+        # Create configuration handler
+        config = Configuration(custom_config)
+        
+        logger.info(f"Data path: {args.data_path}")
+        logger.info(f"Model name: {args.model_name}")
+        logger.info(f"Model folder: {config['model_folder']}")
+        
+        # Initialize components
+        class_map = ClassMap(config)
+        feature_extractor = FeatureExtractor(config)
+        dataset_creator = DatasetLoader(config, feature_extractor)
+        model_builder = ModelBuilder(config)
+        
+        # Update classes and get class list
+        classes = class_map.update_classes(args.data_path)
+        
+        # Create dataset
+        samples, labels = dataset_creator.create_dataset(args.data_path, classes)
+        
+        # Shuffle the data for better training
+        samples, labels = shuffle(samples, labels, random_state=42)
+        
+        # Train model
+        model, encoder = model_builder.train_model(samples, labels, args.model_name)
+        
+        logger.info("Training completed successfully!")
+        
+    except Exception as e:
+        logger.error(f"Error during execution: {str(e)}", exc_info=True)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

yamnet.py

@@ -0,0 +1,164 @@
+"""Core model definition of YAMNet."""
+from tensorflow.keras.models import load_model
+
+import csv
+
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras import Model, layers
+
+import features as features_lib
+
+
+def _batch_norm(name, params):
+    def _bn_layer(layer_input):
+        return layers.BatchNormalization(
+            name=name,
+            center=params.batchnorm_center,
+            scale=params.batchnorm_scale,
+            epsilon=params.batchnorm_epsilon)(layer_input)
+
+    return _bn_layer
+
+
+def _conv(name, kernel, stride, filters, params):
+    def _conv_layer(layer_input):
+        output = layers.Conv2D(name='{}/conv'.format(name),
+                               filters=filters,
+                               kernel_size=kernel,
+                               strides=stride,
+                               padding=params.conv_padding,
+                               use_bias=False,
+                               activation=None)(layer_input)
+        output = _batch_norm('{}/conv/bn'.format(name), params)(output)
+        output = layers.ReLU(name='{}/relu'.format(name))(output)
+        return output
+
+    return _conv_layer
+
+
+def _separable_conv(name, kernel, stride, filters, params):
+    def _separable_conv_layer(layer_input):
+        output = layers.DepthwiseConv2D(name='{}/depthwise_conv'.format(name),
+                                        kernel_size=kernel,
+                                        strides=stride,
+                                        depth_multiplier=1,
+                                        padding=params.conv_padding,
+                                        use_bias=False,
+                                        activation=None)(layer_input)
+        output = _batch_norm('{}/depthwise_conv/bn'.format(name), params)(output)
+        output = layers.ReLU(name='{}/depthwise_conv/relu'.format(name))(output)
+        output = layers.Conv2D(name='{}/pointwise_conv'.format(name),
+                               filters=filters,
+                               kernel_size=(1, 1),
+                               strides=1,
+                               padding=params.conv_padding,
+                               use_bias=False,
+                               activation=None)(output)
+        output = _batch_norm('{}/pointwise_conv/bn'.format(name), params)(output)
+        output = layers.ReLU(name='{}/pointwise_conv/relu'.format(name))(output)
+        return output
+
+    return _separable_conv_layer
+
+
+_YAMNET_LAYER_DEFS = [
+    # (layer_function, kernel, stride, num_filters)
+    (_conv, [3, 3], 2, 32),
+    (_separable_conv, [3, 3], 1, 64),
+    (_separable_conv, [3, 3], 2, 128),
+    (_separable_conv, [3, 3], 1, 128),
+    (_separable_conv, [3, 3], 2, 256),
+    (_separable_conv, [3, 3], 1, 256),
+    (_separable_conv, [3, 3], 2, 512),
+    (_separable_conv, [3, 3], 1, 512),
+    (_separable_conv, [3, 3], 1, 512),
+    (_separable_conv, [3, 3], 1, 512),
+    (_separable_conv, [3, 3], 1, 512),
+    (_separable_conv, [3, 3], 1, 512),
+    (_separable_conv, [3, 3], 2, 1024),
+    (_separable_conv, [3, 3], 1, 1024)
+]
+
+
+def yamnet(features, params):
+    """Define the core YAMNet mode in Keras."""
+    net = layers.Reshape(
+        (params.patch_frames, params.patch_bands, 1),
+        input_shape=(params.patch_frames, params.patch_bands))(features)
+    for (i, (layer_fun, kernel, stride, filters)) in enumerate(_YAMNET_LAYER_DEFS):
+        net = layer_fun('layer{}'.format(i + 1), kernel, stride, filters, params)(net)
+    embeddings = layers.GlobalAveragePooling2D()(net)
+    logits = layers.Dense(units=params.num_classes, use_bias=True)(embeddings)
+    predictions = layers.Activation(activation=params.classifier_activation)(logits)
+    return predictions, embeddings
+
+
+def yamnet_frames_model(params):
+    """Defines the YAMNet waveform-to-class-scores model.
+
+  Args:
+    params: An instance of Params containing hyperparameters.
+
+  Returns:
+    A model accepting (num_samples,) waveform input and emitting:
+    - predictions: (num_patches, num_classes) matrix of class scores per time frame
+    - embeddings: (num_patches, embedding size) matrix of embeddings per time frame
+    - log_mel_spectrogram: (num_spectrogram_frames, num_mel_bins) spectrogram feature matrix
+  """
+    waveform = layers.Input(batch_shape=(None,), dtype=tf.float32)
+    waveform_padded = features_lib.pad_waveform(waveform, params)
+    log_mel_spectrogram, features = features_lib.waveform_to_log_mel_spectrogram_patches(
+        waveform_padded, params)
+    predictions, embeddings = yamnet(features, params)
+    frames_model = Model(
+        name='yamnet_frames', inputs=waveform,
+        outputs=[predictions, embeddings, log_mel_spectrogram])
+    return frames_model
+
+
+def yamnet_transfer(features, params):
+    net = layers.Reshape(
+        (params.patch_frames, params.patch_bands, 1),
+        input_shape=(params.patch_frames, params.patch_bands))(features)
+    for (i, (layer_fun, kernel, stride, filters)) in enumerate(_YAMNET_LAYER_DEFS):
+        net = layer_fun('layer{}'.format(i + 1), kernel, stride, filters, params)(net)
+    embeddings = layers.GlobalAveragePooling2D()(net)
+    return embeddings
+
+
+def yamnet_frames_model_transfer(params, last_layers):
+    """Defines the YAMNet waveform-to-class-scores model.
+
+    Args:
+      params: An instance of Params containing hyperparameters;
+      last_layers: Path to the classifier model.
+    Returns:
+    A model accepting (num_samples,) waveform input and emitting:
+    - predictions: (num_patches, num_classes) matrix of class scores per time frame
+    - embeddings: (num_patches, embedding size) matrix of embeddings per time frame
+    """
+
+    waveform = layers.Input(batch_shape=(None,), dtype=tf.float32)
+    waveform_padded = features_lib.pad_waveform(waveform, params)
+    _, features = features_lib.waveform_to_log_mel_spectrogram_patches(
+        waveform_padded, params)
+    embeddings = yamnet_transfer(features, params)
+    prediction = embeddings
+    last_layers = load_model(last_layers)
+    for layer in last_layers.layers[1:]:
+        prediction = layer(prediction)
+    frames_model = Model(
+        name='yamnet_frames', inputs=waveform,
+        outputs=[prediction, embeddings])
+    return frames_model
+
+
+def class_names(class_map_csv):
+    """Read the class name definition file and return a list of strings."""
+    if tf.is_tensor(class_map_csv):
+        class_map_csv = class_map_csv.numpy()
+    with open(class_map_csv) as csv_file:
+        reader = csv.reader(csv_file)
+        next(reader)  # Skip header
+        return np.array([display_name for (_, _, display_name) in reader])

yamnet/yamnet.h5

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

yamnet/yamnet_class_map.csv

@@ -0,0 +1,526 @@
+index,mid,display_name
+0.0,/m/09x0r,Speech
+1.0,/m/0ytgt,"Child speech, kid speaking"
+2.0,/m/01h8n0,Conversation
+3.0,/m/02qldy,"Narration, monologue"
+4.0,/m/0261r1,Babbling
+5.0,/m/0brhx,Speech synthesizer
+6.0,/m/07p6fty,Shout
+7.0,/m/07q4ntr,Bellow
+8.0,/m/07rwj3x,Whoop
+9.0,/m/07sr1lc,Yell
+10.0,/t/dd00135,Children shouting
+11.0,/m/03qc9zr,Screaming
+12.0,/m/02rtxlg,Whispering
+13.0,/m/01j3sz,Laughter
+14.0,/t/dd00001,Baby laughter
+15.0,/m/07r660_,Giggle
+16.0,/m/07s04w4,Snicker
+17.0,/m/07sq110,Belly laugh
+18.0,/m/07rgt08,"Chuckle, chortle"
+19.0,/m/0463cq4,"Crying, sobbing"
+20.0,/t/dd00002,"Baby cry, infant cry"
+21.0,/m/07qz6j3,Whimper
+22.0,/m/07qw_06,"Wail, moan"
+23.0,/m/07plz5l,Sigh
+24.0,/m/015lz1,Singing
+25.0,/m/0l14jd,Choir
+26.0,/m/01swy6,Yodeling
+27.0,/m/02bk07,Chant
+28.0,/m/01c194,Mantra
+29.0,/t/dd00005,Child singing
+30.0,/t/dd00006,Synthetic singing
+31.0,/m/06bxc,Rapping
+32.0,/m/02fxyj,Humming
+33.0,/m/07s2xch,Groan
+34.0,/m/07r4k75,Grunt
+35.0,/m/01w250,Whistling
+36.0,/m/0lyf6,Breathing
+37.0,/m/07mzm6,Wheeze
+38.0,/m/01d3sd,Snoring
+39.0,/m/07s0dtb,Gasp
+40.0,/m/07pyy8b,Pant
+41.0,/m/07q0yl5,Snort
+42.0,/m/01b_21,Cough
+43.0,/m/0dl9sf8,Throat clearing
+44.0,/m/01hsr_,Sneeze
+45.0,/m/07ppn3j,Sniff
+46.0,/m/06h7j,Run
+47.0,/m/07qv_x_,Shuffle
+48.0,/m/07pbtc8,"Walk, footsteps"
+49.0,/m/03cczk,"Chewing, mastication"
+50.0,/m/07pdhp0,Biting
+51.0,/m/0939n_,Gargling
+52.0,/m/01g90h,Stomach rumble
+53.0,/m/03q5_w,"Burping, eructation"
+54.0,/m/02p3nc,Hiccup
+55.0,/m/02_nn,Fart
+56.0,/m/0k65p,Hands
+57.0,/m/025_jnm,Finger snapping
+58.0,/m/0l15bq,Clapping
+59.0,/m/01jg02,"Heart sounds, heartbeat"
+60.0,/m/01jg1z,Heart murmur
+61.0,/m/053hz1,Cheering
+62.0,/m/028ght,Applause
+63.0,/m/07rkbfh,Chatter
+64.0,/m/03qtwd,Crowd
+65.0,/m/07qfr4h,"Hubbub, speech noise, speech babble"
+66.0,/t/dd00013,Children playing
+67.0,/m/0jbk,Animal
+68.0,/m/068hy,"Domestic animals, pets"
+69.0,/m/0bt9lr,Dog
+70.0,/m/05tny_,Bark
+71.0,/m/07r_k2n,Yip
+72.0,/m/07qf0zm,Howl
+73.0,/m/07rc7d9,Bow-wow
+74.0,/m/0ghcn6,Growling
+75.0,/t/dd00136,Whimper (dog)
+76.0,/m/01yrx,Cat
+77.0,/m/02yds9,Purr
+78.0,/m/07qrkrw,Meow
+79.0,/m/07rjwbb,Hiss
+80.0,/m/07r81j2,Caterwaul
+81.0,/m/0ch8v,"Livestock, farm animals, working animals"
+82.0,/m/03k3r,Horse
+83.0,/m/07rv9rh,Clip-clop
+84.0,/m/07q5rw0,"Neigh, whinny"
+85.0,/m/01xq0k1,"Cattle, bovinae"
+86.0,/m/07rpkh9,Moo
+87.0,/m/0239kh,Cowbell
+88.0,/m/068zj,Pig
+89.0,/t/dd00018,Oink
+90.0,/m/03fwl,Goat
+91.0,/m/07q0h5t,Bleat
+92.0,/m/07bgp,Sheep
+93.0,/m/025rv6n,Fowl
+94.0,/m/09b5t,"Chicken, rooster"
+95.0,/m/07st89h,Cluck
+96.0,/m/07qn5dc,"Crowing, cock-a-doodle-doo"
+97.0,/m/01rd7k,Turkey
+98.0,/m/07svc2k,Gobble
+99.0,/m/09ddx,Duck
+100.0,/m/07qdb04,Quack
+101.0,/m/0dbvp,Goose
+102.0,/m/07qwf61,Honk
+103.0,/m/01280g,Wild animals
+104.0,/m/0cdnk,"Roaring cats (lions, tigers)"
+105.0,/m/04cvmfc,Roar
+106.0,/m/015p6,Bird
+107.0,/m/020bb7,"Bird vocalization, bird call, bird song"
+108.0,/m/07pggtn,"Chirp, tweet"
+109.0,/m/07sx8x_,Squawk
+110.0,/m/0h0rv,"Pigeon, dove"
+111.0,/m/07r_25d,Coo
+112.0,/m/04s8yn,Crow
+113.0,/m/07r5c2p,Caw
+114.0,/m/09d5_,Owl
+115.0,/m/07r_80w,Hoot
+116.0,/m/05_wcq,"Bird flight, flapping wings"
+117.0,/m/01z5f,"Canidae, dogs, wolves"
+118.0,/m/06hps,"Rodents, rats, mice"
+119.0,/m/04rmv,Mouse
+120.0,/m/07r4gkf,Patter
+121.0,/m/03vt0,Insect
+122.0,/m/09xqv,Cricket
+123.0,/m/09f96,Mosquito
+124.0,/m/0h2mp,"Fly, housefly"
+125.0,/m/07pjwq1,Buzz
+126.0,/m/01h3n,"Bee, wasp, etc."
+127.0,/m/09ld4,Frog
+128.0,/m/07st88b,Croak
+129.0,/m/078jl,Snake
+130.0,/m/07qn4z3,Rattle
+131.0,/m/032n05,Whale vocalization
+132.0,/m/04rlf,Music
+133.0,/m/04szw,Musical instrument
+134.0,/m/0fx80y,Plucked string instrument
+135.0,/m/0342h,Guitar
+136.0,/m/02sgy,Electric guitar
+137.0,/m/018vs,Bass guitar
+138.0,/m/042v_gx,Acoustic guitar
+139.0,/m/06w87,"Steel guitar, slide guitar"
+140.0,/m/01glhc,Tapping (guitar technique)
+141.0,/m/07s0s5r,Strum
+142.0,/m/018j2,Banjo
+143.0,/m/0jtg0,Sitar
+144.0,/m/04rzd,Mandolin
+145.0,/m/01bns_,Zither
+146.0,/m/07xzm,Ukulele
+147.0,/m/05148p4,Keyboard (musical)
+148.0,/m/05r5c,Piano
+149.0,/m/01s0ps,Electric piano
+150.0,/m/013y1f,Organ
+151.0,/m/03xq_f,Electronic organ
+152.0,/m/03gvt,Hammond organ
+153.0,/m/0l14qv,Synthesizer
+154.0,/m/01v1d8,Sampler
+155.0,/m/03q5t,Harpsichord
+156.0,/m/0l14md,Percussion
+157.0,/m/02hnl,Drum kit
+158.0,/m/0cfdd,Drum machine
+159.0,/m/026t6,Drum
+160.0,/m/06rvn,Snare drum
+161.0,/m/03t3fj,Rimshot
+162.0,/m/02k_mr,Drum roll
+163.0,/m/0bm02,Bass drum
+164.0,/m/011k_j,Timpani
+165.0,/m/01p970,Tabla
+166.0,/m/01qbl,Cymbal
+167.0,/m/03qtq,Hi-hat
+168.0,/m/01sm1g,Wood block
+169.0,/m/07brj,Tambourine
+170.0,/m/05r5wn,Rattle (instrument)
+171.0,/m/0xzly,Maraca
+172.0,/m/0mbct,Gong
+173.0,/m/016622,Tubular bells
+174.0,/m/0j45pbj,Mallet percussion
+175.0,/m/0dwsp,"Marimba, xylophone"
+176.0,/m/0dwtp,Glockenspiel
+177.0,/m/0dwt5,Vibraphone
+178.0,/m/0l156b,Steelpan
+179.0,/m/05pd6,Orchestra
+180.0,/m/01kcd,Brass instrument
+181.0,/m/0319l,French horn
+182.0,/m/07gql,Trumpet
+183.0,/m/07c6l,Trombone
+184.0,/m/0l14_3,Bowed string instrument
+185.0,/m/02qmj0d,String section
+186.0,/m/07y_7,"Violin, fiddle"
+187.0,/m/0d8_n,Pizzicato
+188.0,/m/01xqw,Cello
+189.0,/m/02fsn,Double bass
+190.0,/m/085jw,"Wind instrument, woodwind instrument"
+191.0,/m/0l14j_,Flute
+192.0,/m/06ncr,Saxophone
+193.0,/m/01wy6,Clarinet
+194.0,/m/03m5k,Harp
+195.0,/m/0395lw,Bell
+196.0,/m/03w41f,Church bell
+197.0,/m/027m70_,Jingle bell
+198.0,/m/0gy1t2s,Bicycle bell
+199.0,/m/07n_g,Tuning fork
+200.0,/m/0f8s22,Chime
+201.0,/m/026fgl,Wind chime
+202.0,/m/0150b9,Change ringing (campanology)
+203.0,/m/03qjg,Harmonica
+204.0,/m/0mkg,Accordion
+205.0,/m/0192l,Bagpipes
+206.0,/m/02bxd,Didgeridoo
+207.0,/m/0l14l2,Shofar
+208.0,/m/07kc_,Theremin
+209.0,/m/0l14t7,Singing bowl
+210.0,/m/01hgjl,Scratching (performance technique)
+211.0,/m/064t9,Pop music
+212.0,/m/0glt670,Hip hop music
+213.0,/m/02cz_7,Beatboxing
+214.0,/m/06by7,Rock music
+215.0,/m/03lty,Heavy metal
+216.0,/m/05r6t,Punk rock
+217.0,/m/0dls3,Grunge
+218.0,/m/0dl5d,Progressive rock
+219.0,/m/07sbbz2,Rock and roll
+220.0,/m/05w3f,Psychedelic rock
+221.0,/m/06j6l,Rhythm and blues
+222.0,/m/0gywn,Soul music
+223.0,/m/06cqb,Reggae
+224.0,/m/01lyv,Country
+225.0,/m/015y_n,Swing music
+226.0,/m/0gg8l,Bluegrass
+227.0,/m/02x8m,Funk
+228.0,/m/02w4v,Folk music
+229.0,/m/06j64v,Middle Eastern music
+230.0,/m/03_d0,Jazz
+231.0,/m/026z9,Disco
+232.0,/m/0ggq0m,Classical music
+233.0,/m/05lls,Opera
+234.0,/m/02lkt,Electronic music
+235.0,/m/03mb9,House music
+236.0,/m/07gxw,Techno
+237.0,/m/07s72n,Dubstep
+238.0,/m/0283d,Drum and bass
+239.0,/m/0m0jc,Electronica
+240.0,/m/08cyft,Electronic dance music
+241.0,/m/0fd3y,Ambient music
+242.0,/m/07lnk,Trance music
+243.0,/m/0g293,Music of Latin America
+244.0,/m/0ln16,Salsa music
+245.0,/m/0326g,Flamenco
+246.0,/m/0155w,Blues
+247.0,/m/05fw6t,Music for children
+248.0,/m/02v2lh,New-age music
+249.0,/m/0y4f8,Vocal music
+250.0,/m/0z9c,A capella
+251.0,/m/0164x2,Music of Africa
+252.0,/m/0145m,Afrobeat
+253.0,/m/02mscn,Christian music
+254.0,/m/016cjb,Gospel music
+255.0,/m/028sqc,Music of Asia
+256.0,/m/015vgc,Carnatic music
+257.0,/m/0dq0md,Music of Bollywood
+258.0,/m/06rqw,Ska
+259.0,/m/02p0sh1,Traditional music
+260.0,/m/05rwpb,Independent music
+261.0,/m/074ft,Song
+262.0,/m/025td0t,Background music
+263.0,/m/02cjck,Theme music
+264.0,/m/03r5q_,Jingle (music)
+265.0,/m/0l14gg,Soundtrack music
+266.0,/m/07pkxdp,Lullaby
+267.0,/m/01z7dr,Video game music
+268.0,/m/0140xf,Christmas music
+269.0,/m/0ggx5q,Dance music
+270.0,/m/04wptg,Wedding music
+271.0,/t/dd00031,Happy music
+272.0,/t/dd00033,Sad music
+273.0,/t/dd00034,Tender music
+274.0,/t/dd00035,Exciting music
+275.0,/t/dd00036,Angry music
+276.0,/t/dd00037,Scary music
+277.0,/m/03m9d0z,Wind
+278.0,/m/09t49,Rustling leaves
+279.0,/t/dd00092,Wind noise (microphone)
+280.0,/m/0jb2l,Thunderstorm
+281.0,/m/0ngt1,Thunder
+282.0,/m/0838f,Water
+283.0,/m/06mb1,Rain
+284.0,/m/07r10fb,Raindrop
+285.0,/t/dd00038,Rain on surface
+286.0,/m/0j6m2,Stream
+287.0,/m/0j2kx,Waterfall
+288.0,/m/05kq4,Ocean
+289.0,/m/034srq,"Waves, surf"
+290.0,/m/06wzb,Steam
+291.0,/m/07swgks,Gurgling
+292.0,/m/02_41,Fire
+293.0,/m/07pzfmf,Crackle
+294.0,/m/07yv9,Vehicle
+295.0,/m/019jd,"Boat, Water vehicle"
+296.0,/m/0hsrw,"Sailboat, sailing ship"
+297.0,/m/056ks2,"Rowboat, canoe, kayak"
+298.0,/m/02rlv9,"Motorboat, speedboat"
+299.0,/m/06q74,Ship
+300.0,/m/012f08,Motor vehicle (road)
+301.0,/m/0k4j,Car
+302.0,/m/0912c9,"Vehicle horn, car horn, honking"
+303.0,/m/07qv_d5,Toot
+304.0,/m/02mfyn,Car alarm
+305.0,/m/04gxbd,"Power windows, electric windows"
+306.0,/m/07rknqz,Skidding
+307.0,/m/0h9mv,Tire squeal
+308.0,/t/dd00134,Car passing by
+309.0,/m/0ltv,"Race car, auto racing"
+310.0,/m/07r04,Truck
+311.0,/m/0gvgw0,Air brake
+312.0,/m/05x_td,"Air horn, truck horn"
+313.0,/m/02rhddq,Reversing beeps
+314.0,/m/03cl9h,"Ice cream truck, ice cream van"
+315.0,/m/01bjv,Bus
+316.0,/m/03j1ly,Emergency vehicle
+317.0,/m/04qvtq,Police car (siren)
+318.0,/m/012n7d,Ambulance (siren)
+319.0,/m/012ndj,"Fire engine, fire truck (siren)"
+320.0,/m/04_sv,Motorcycle
+321.0,/m/0btp2,"Traffic noise, roadway noise"
+322.0,/m/06d_3,Rail transport
+323.0,/m/07jdr,Train
+324.0,/m/04zmvq,Train whistle
+325.0,/m/0284vy3,Train horn
+326.0,/m/01g50p,"Railroad car, train wagon"
+327.0,/t/dd00048,Train wheels squealing
+328.0,/m/0195fx,"Subway, metro, underground"
+329.0,/m/0k5j,Aircraft
+330.0,/m/014yck,Aircraft engine
+331.0,/m/04229,Jet engine
+332.0,/m/02l6bg,"Propeller, airscrew"
+333.0,/m/09ct_,Helicopter
+334.0,/m/0cmf2,"Fixed-wing aircraft, airplane"
+335.0,/m/0199g,Bicycle
+336.0,/m/06_fw,Skateboard
+337.0,/m/02mk9,Engine
+338.0,/t/dd00065,Light engine (high frequency)
+339.0,/m/08j51y,"Dental drill, dentist's drill"
+340.0,/m/01yg9g,Lawn mower
+341.0,/m/01j4z9,Chainsaw
+342.0,/t/dd00066,Medium engine (mid frequency)
+343.0,/t/dd00067,Heavy engine (low frequency)
+344.0,/m/01h82_,Engine knocking
+345.0,/t/dd00130,Engine starting
+346.0,/m/07pb8fc,Idling
+347.0,/m/07q2z82,"Accelerating, revving, vroom"
+348.0,/m/02dgv,Door
+349.0,/m/03wwcy,Doorbell
+350.0,/m/07r67yg,Ding-dong
+351.0,/m/02y_763,Sliding door
+352.0,/m/07rjzl8,Slam
+353.0,/m/07r4wb8,Knock
+354.0,/m/07qcpgn,Tap
+355.0,/m/07q6cd_,Squeak
+356.0,/m/0642b4,Cupboard open or close
+357.0,/m/0fqfqc,Drawer open or close
+358.0,/m/04brg2,"Dishes, pots, and pans"
+359.0,/m/023pjk,"Cutlery, silverware"
+360.0,/m/07pn_8q,Chopping (food)
+361.0,/m/0dxrf,Frying (food)
+362.0,/m/0fx9l,Microwave oven
+363.0,/m/02pjr4,Blender
+364.0,/m/02jz0l,"Water tap, faucet"
+365.0,/m/0130jx,Sink (filling or washing)
+366.0,/m/03dnzn,Bathtub (filling or washing)
+367.0,/m/03wvsk,Hair dryer
+368.0,/m/01jt3m,Toilet flush
+369.0,/m/012xff,Toothbrush
+370.0,/m/04fgwm,Electric toothbrush
+371.0,/m/0d31p,Vacuum cleaner
+372.0,/m/01s0vc,Zipper (clothing)
+373.0,/m/03v3yw,Keys jangling
+374.0,/m/0242l,Coin (dropping)
+375.0,/m/01lsmm,Scissors
+376.0,/m/02g901,"Electric shaver, electric razor"
+377.0,/m/05rj2,Shuffling cards
+378.0,/m/0316dw,Typing
+379.0,/m/0c2wf,Typewriter
+380.0,/m/01m2v,Computer keyboard
+381.0,/m/081rb,Writing
+382.0,/m/07pp_mv,Alarm
+383.0,/m/07cx4,Telephone
+384.0,/m/07pp8cl,Telephone bell ringing
+385.0,/m/01hnzm,Ringtone
+386.0,/m/02c8p,"Telephone dialing, DTMF"
+387.0,/m/015jpf,Dial tone
+388.0,/m/01z47d,Busy signal
+389.0,/m/046dlr,Alarm clock
+390.0,/m/03kmc9,Siren
+391.0,/m/0dgbq,Civil defense siren
+392.0,/m/030rvx,Buzzer
+393.0,/m/01y3hg,"Smoke detector, smoke alarm"
+394.0,/m/0c3f7m,Fire alarm
+395.0,/m/04fq5q,Foghorn
+396.0,/m/0l156k,Whistle
+397.0,/m/06hck5,Steam whistle
+398.0,/t/dd00077,Mechanisms
+399.0,/m/02bm9n,"Ratchet, pawl"
+400.0,/m/01x3z,Clock
+401.0,/m/07qjznt,Tick
+402.0,/m/07qjznl,Tick-tock
+403.0,/m/0l7xg,Gears
+404.0,/m/05zc1,Pulleys
+405.0,/m/0llzx,Sewing machine
+406.0,/m/02x984l,Mechanical fan
+407.0,/m/025wky1,Air conditioning
+408.0,/m/024dl,Cash register
+409.0,/m/01m4t,Printer
+410.0,/m/0dv5r,Camera
+411.0,/m/07bjf,Single-lens reflex camera
+412.0,/m/07k1x,Tools
+413.0,/m/03l9g,Hammer
+414.0,/m/03p19w,Jackhammer
+415.0,/m/01b82r,Sawing
+416.0,/m/02p01q,Filing (rasp)
+417.0,/m/023vsd,Sanding
+418.0,/m/0_ksk,Power tool
+419.0,/m/01d380,Drill
+420.0,/m/014zdl,Explosion
+421.0,/m/032s66,"Gunshot, gunfire"
+422.0,/m/04zjc,Machine gun
+423.0,/m/02z32qm,Fusillade
+424.0,/m/0_1c,Artillery fire
+425.0,/m/073cg4,Cap gun
+426.0,/m/0g6b5,Fireworks
+427.0,/g/122z_qxw,Firecracker
+428.0,/m/07qsvvw,"Burst, pop"
+429.0,/m/07pxg6y,Eruption
+430.0,/m/07qqyl4,Boom
+431.0,/m/083vt,Wood
+432.0,/m/07pczhz,Chop
+433.0,/m/07pl1bw,Splinter
+434.0,/m/07qs1cx,Crack
+435.0,/m/039jq,Glass
+436.0,/m/07q7njn,"Chink, clink"
+437.0,/m/07rn7sz,Shatter
+438.0,/m/04k94,Liquid
+439.0,/m/07rrlb6,"Splash, splatter"
+440.0,/m/07p6mqd,Slosh
+441.0,/m/07qlwh6,Squish
+442.0,/m/07r5v4s,Drip
+443.0,/m/07prgkl,Pour
+444.0,/m/07pqc89,"Trickle, dribble"
+445.0,/t/dd00088,Gush
+446.0,/m/07p7b8y,Fill (with liquid)
+447.0,/m/07qlf79,Spray
+448.0,/m/07ptzwd,Pump (liquid)
+449.0,/m/07ptfmf,Stir
+450.0,/m/0dv3j,Boiling
+451.0,/m/0790c,Sonar
+452.0,/m/0dl83,Arrow
+453.0,/m/07rqsjt,"Whoosh, swoosh, swish"
+454.0,/m/07qnq_y,"Thump, thud"
+455.0,/m/07rrh0c,Thunk
+456.0,/m/0b_fwt,Electronic tuner
+457.0,/m/02rr_,Effects unit
+458.0,/m/07m2kt,Chorus effect
+459.0,/m/018w8,Basketball bounce
+460.0,/m/07pws3f,Bang
+461.0,/m/07ryjzk,"Slap, smack"
+462.0,/m/07rdhzs,"Whack, thwack"
+463.0,/m/07pjjrj,"Smash, crash"
+464.0,/m/07pc8lb,Breaking
+465.0,/m/07pqn27,Bouncing
+466.0,/m/07rbp7_,Whip
+467.0,/m/07pyf11,Flap
+468.0,/m/07qb_dv,Scratch
+469.0,/m/07qv4k0,Scrape
+470.0,/m/07pdjhy,Rub
+471.0,/m/07s8j8t,Roll
+472.0,/m/07plct2,Crushing
+473.0,/t/dd00112,"Crumpling, crinkling"
+474.0,/m/07qcx4z,Tearing
+475.0,/m/02fs_r,"Beep, bleep"
+476.0,/m/07qwdck,Ping
+477.0,/m/07phxs1,Ding
+478.0,/m/07rv4dm,Clang
+479.0,/m/07s02z0,Squeal
+480.0,/m/07qh7jl,Creak
+481.0,/m/07qwyj0,Rustle
+482.0,/m/07s34ls,Whir
+483.0,/m/07qmpdm,Clatter
+484.0,/m/07p9k1k,Sizzle
+485.0,/m/07qc9xj,Clicking
+486.0,/m/07rwm0c,Clickety-clack
+487.0,/m/07phhsh,Rumble
+488.0,/m/07qyrcz,Plop
+489.0,/m/07qfgpx,"Jingle, tinkle"
+490.0,/m/07rcgpl,Hum
+491.0,/m/07p78v5,Zing
+492.0,/t/dd00121,Boing
+493.0,/m/07s12q4,Crunch
+494.0,/m/028v0c,Silence
+495.0,/m/01v_m0,Sine wave
+496.0,/m/0b9m1,Harmonic
+497.0,/m/0hdsk,Chirp tone
+498.0,/m/0c1dj,Sound effect
+499.0,/m/07pt_g0,Pulse
+500.0,/t/dd00125,"Inside, small room"
+501.0,/t/dd00126,"Inside, large room or hall"
+502.0,/t/dd00127,"Inside, public space"
+503.0,/t/dd00128,"Outside, urban or manmade"
+504.0,/t/dd00129,"Outside, rural or natural"
+505.0,/m/01b9nn,Reverberation
+506.0,/m/01jnbd,Echo
+507.0,/m/096m7z,Noise
+508.0,/m/06_y0by,Environmental noise
+509.0,/m/07rgkc5,Static
+510.0,/m/06xkwv,Mains hum
+511.0,/m/0g12c5,Distortion
+512.0,/m/08p9q4,Sidetone
+513.0,/m/07szfh9,Cacophony
+514.0,/m/0chx_,White noise
+515.0,/m/0cj0r,Pink noise
+516.0,/m/07p_0gm,Throbbing
+517.0,/m/01jwx6,Vibration
+518.0,/m/07c52,Television
+519.0,/m/06bz3,Radio
+520.0,/m/07hvw1,Field recording
+,,queen not present
+,,queen present and rejected
+,,queen present and newly accepted
+,,queen present or original queen

yamnet_test.py

@@ -0,0 +1,56 @@
+"""Installation test for YAMNet."""
+
+import numpy as np
+import tensorflow as tf
+
+import params
+import yamnet
+
+
+class YAMNetTest(tf.test.TestCase):
+  _params = None
+  _yamnet = None
+  _yamnet_classes = None
+
+  @classmethod
+  def setUpClass(cls):
+    super().setUpClass()
+    cls._params = params.Params()
+    cls._yamnet = yamnet.yamnet_frames_model(cls._params)
+    cls._yamnet.load_weights('yamnet/yamnet.h5')
+    cls._yamnet_classes = yamnet.class_names('yamnet/yamnet_class_map.csv')
+
+  def clip_test(self, waveform, expected_class_name, top_n=10):
+    """Run the model on the waveform, check that expected class is in top-n."""
+    predictions, _, _ = YAMNetTest._yamnet(waveform)
+    clip_predictions = np.mean(predictions, axis=0)
+    top_n_indices = np.argsort(clip_predictions)[-top_n:]
+    top_n_scores = clip_predictions[top_n_indices]
+    top_n_class_names = YAMNetTest._yamnet_classes[top_n_indices]
+    top_n_predictions = list(zip(top_n_class_names, top_n_scores))
+    self.assertIn(expected_class_name, top_n_class_names,
+                  'Did not find expected class {} in top {} predictions: {}'.format(
+                      expected_class_name, top_n, top_n_predictions))
+
+  def testZeros(self):
+    self.clip_test(
+        waveform=np.zeros((int(3 * YAMNetTest._params.sample_rate),)),
+        expected_class_name='Silence')
+
+  def testRandom(self):
+    # Create a numpy random Generator with a fixed seed for repeatability
+    rng = np.random.default_rng(51773)
+    self.clip_test(
+        waveform=rng.uniform(-1.0, +1.0,
+                              (int(3 * YAMNetTest._params.sample_rate),)),
+        expected_class_name='White noise')
+
+  def testSine(self):
+    self.clip_test(
+        waveform=np.sin(2 * np.pi * 440 *
+                        np.arange(0, 3, 1 / YAMNetTest._params.sample_rate)),
+        expected_class_name='Sine wave')
+
+
+if __name__ == '__main__':
+  tf.test.main()