playlist-data-engine 1.1.0

package/dist/core/analysis/MusicClassifier.d.ts

@@ -0,0 +1,524 @@
+import type { MusicClassificationProfile } from '../types/AudioProfile.js';
+/**
+ * Supported model architectures for audio feature extraction.
+ * Each architecture requires different mel-band configurations:
+ * - `musicnn`: 96 mel bands - MusiCNN / MSD style models
+ * - `effnet`: 128 mel bands - Discogs-EffNet embedding models
+ * - `vggish`: 64 mel bands - VGGish-based models (e.g., audioset classifiers)
+ * - `tempocnn`: 40 mel bands - TempoCNN-based models (e.g., tempo estimation)
+ */
+export type ModelArchitecture = 'musicnn' | 'effnet' | 'vggish' | 'tempocnn';
+/**
+ * Supported genre list types for different model sources.
+ * Each genre model was trained on a specific dataset with its own genre taxonomy:
+ * - `jamendo`: MTG Jamendo dataset (87 genres)
+ * - `discogs400`: Discogs 400-style taxonomy (400+ subgenres)
+ * - `tzanetakis`: GTZAN dataset (10 classic genres)
+ * - `mtt_musicnn`: MTT (MagnaTagATune) with MusiCNN tags (50 tags)
+ */
+export type GenreListType = 'jamendo' | 'discogs400' | 'tzanetakis' | 'mtt_musicnn';
+/**
+ * Configuration for two-step model architectures where embedding
+ * and classifier models are separate files.
+ *
+ * This enables using models like:
+ * - Discogs-EffNet (embedding) + MTG Jamendo Genre (classifier)
+ * - Discogs-EffNet (embedding) + MTG Jamendo Mood (classifier)
+ */
+export interface TwoStepModelConfig {
+    /** URL to the embedding model (e.g., discogs-effnet-bs64-1.json) */
+    embedding: string;
+    /** URL to the classifier model that operates on embeddings */
+    classifier: string;
+    /** Optional custom labels for classifier output */
+    labels?: string[];
+    /** Explicit embedding architecture type (overrides URL detection) */
+    embeddingType?: ModelArchitecture;
+    /** Explicit classifier type for genre models (overrides URL detection) */
+    classifierType?: GenreListType;
+}
+/**
+ * Configuration for single-step model architecture where one model
+ * handles feature extraction and classification internally.
+ */
+export interface SingleStepModelConfig {
+    /** URL to the model file */
+    modelUrl: string;
+    /** Explicit model architecture type (overrides URL detection) */
+    modelType: ModelArchitecture;
+    /**
+     * Explicit genre list type for genre models (overrides URL detection).
+     * Required when using Arweave URLs that don't contain genre identifiers.
+     */
+    genreType?: GenreListType;
+    /** Optional custom labels for model output */
+    labels?: string[];
+}
+/**
+ * Model configuration that accepts either:
+ * - SingleStepModelConfig: One model with explicit architecture type
+ * - TwoStepModelConfig: Separate embedding + classifier models chained together
+ *
+ * @example
+ * // Single-step with explicit type (for Arweave URLs)
+ * genre: {
+ *     modelUrl: 'https://arweave.net/xxx/model.json',
+ *     modelType: 'musicnn'
+ * }
+ *
+ * // Two-step
+ * genre: {
+ *     embedding: '/models/discogs-effnet-bs64-1.json',
+ *     classifier: '/models/mtg_jamendo_genre-discogs-effnet-1.json',
+ *     embeddingType: 'effnet',
+ *     classifierType: 'jamendo'
+ * }
+ */
+export type ModelConfig = SingleStepModelConfig | TwoStepModelConfig;
+/**
+ * Preset names for genre classification models.
+ */
+export type GenrePreset = 'discogs400' | 'jamendo' | 'tzanetakis' | 'musicnn';
+/**
+ * Preset names for mood classification models.
+ */
+export type MoodPreset = 'jamendo' | 'happyMusicnn';
+/**
+ * Preset names for danceability classification models.
+ */
+export type DanceabilityPreset = 'default';
+/**
+ * Configuration that selects models by preset name instead of raw URLs.
+ * Presets are resolved to full model configs internally.
+ *
+ * @example
+ * // Use presets
+ * const classifier = new MusicClassifier({ preset: { genre: 'discogs400', mood: 'jamendo' } });
+ *
+ * // Mix presets with custom URLs
+ * const classifier = new MusicClassifier({
+ *     preset: { genre: 'jamendo' },
+ *     models: { mood: { modelUrl: 'https://...', modelType: 'musicnn' } }
+ * });
+ */
+export interface ClassifierPreset {
+    genre?: GenrePreset;
+    mood?: MoodPreset;
+    danceability?: DanceabilityPreset;
+}
+export interface MusicClassifierOptions {
+    /**
+     * Model preset names. When provided, these are resolved to full model configs
+     * internally. Can be combined with `models` for partial override — explicit
+     * `models` entries take precedence over `preset` entries for the same category.
+     */
+    preset?: ClassifierPreset;
+    /**
+     * URLs to pre-trained TensorFlow.js models.
+     * Each model option accepts EITHER:
+     * - Single string URL (1-step process)
+     * - Object with { embedding, classifier } for 2-step process
+     */
+    models?: {
+        genre?: ModelConfig;
+        mood?: ModelConfig;
+        danceability?: ModelConfig;
+        voice?: ModelConfig;
+        acoustic?: ModelConfig;
+    };
+    /** Maximum number of tags to return per category */
+    topN?: number;
+    /** Minimum confidence threshold (0.0 to 1.0) */
+    threshold?: number;
+    /**
+     * When true, embedding models are cached and reused across multiple
+     * predictions. Useful when using the same embedding model for both
+     * genre and mood classification.
+     * @default true
+     */
+    cacheEmbeddings?: boolean;
+    /**
+     * Optional callback to resolve Arweave URLs before loading models.
+     * Used by the ArweaveGatewayManager to try alternate gateways if
+     * the primary gateway fails (e.g., turbo-gateway.com returning 499 errors).
+     *
+     * The callback takes a URL string and returns a Promise that resolves
+     * to the working URL (possibly from a different gateway).
+     *
+     * @example
+     * ```typescript
+     * import { arweaveGatewayManager } from 'playlist-data-engine';
+     *
+     * const classifier = new MusicClassifier({
+     *   resolveUrl: arweaveGatewayManager.resolveUrl.bind(arweaveGatewayManager),
+     *   models: { genre: 'https://arweave.net/...' }
+     * });
+     * ```
+     */
+    resolveUrl?: (url: string) => Promise<string>;
+}
+export declare const DISCOGS400_GENRES: string[];
+/**
+ * Type guard to check if a model config is a two-step configuration
+ * (embedding + classifier) or a single model URL string.
+ */
+export declare function isTwoStepModel(config: ModelConfig): config is TwoStepModelConfig;
+/**
+ * Type guard to check if a model config is a single-step configuration.
+ */
+export declare function isSingleStepModel(config: ModelConfig): config is SingleStepModelConfig;
+/**
+ * Detects the model architecture from a model URL.
+ * Used to select the correct feature extractor (mel-band count) and model class.
+ *
+ * Architecture → Mel Bands mapping:
+ * - effnet: 128 bands (Discogs-EffNet)
+ * - vggish: 64 bands
+ * - tempocnn: 40 bands
+ * - musicnn: 96 bands (default)
+ *
+ * @param modelUrl - URL to the model file
+ * @param explicitType - Optional explicit architecture type (overrides URL detection)
+ * @returns The detected architecture type
+ */
+export declare function detectModelArchitecture(modelUrl: string, explicitType?: ModelArchitecture): ModelArchitecture;
+/**
+ * Detects which genre list to use based on the model URL.
+ * Different genre models were trained on different datasets with different taxonomies:
+ *
+ * Model path keywords → Genre list:
+ * - 'jamendo' → JAMENDO_GENRES (MTG Jamendo dataset)
+ * - 'discogs400' or 'discogs' → DISCOGS400_GENRES (Discogs taxonomy)
+ * - 'tzanetakis' → tzanetakis_GENRES (GTZAN 10-class dataset)
+ * - 'mtt_musicnn' or 'mtt' → MTT_MUSICNN (MagnaTagATune tags)
+ *
+ * @param modelUrl - URL to the genre model file
+ * @param explicitType - Optional explicit genre list type (overrides URL detection)
+ * @returns The detected genre list type
+ */
+export declare function detectGenreListType(modelUrl: string, explicitType?: GenreListType): GenreListType;
+/**
+ * Gets the genre labels array for a given genre list type.
+ *
+ * @param genreType - The genre list type
+ * @returns Array of genre label strings
+ */
+export declare function getGenreLabels(genreType: GenreListType): string[];
+/**
+ * Formats a model config for display in metadata.
+ * - Single-step: just the URL
+ * - Two-step: "embedding -> classifier" format
+ */
+export declare function formatModelForMetadata(config: ModelConfig): string;
+/**
+ * Averages embeddings across all audio frames.
+ * Used in two-step model architecture to aggregate frame-level embeddings
+ * before passing to the classifier.
+ *
+ * @param embeddings - 2D array of embeddings, shape [frames][embedding_dim]
+ * @returns 1D array of averaged embeddings, shape [embedding_dim]
+ *
+ * @example
+ * const frameEmbeddings = [[0.1, 0.2, 0.3], [0.2, 0.3, 0.4]];
+ * const avgEmbedding = averageEmbeddings(frameEmbeddings);
+ * // Result: [0.15, 0.25, 0.35]
+ */
+export declare function averageEmbeddings(embeddings: number[][]): number[];
+/**
+ * Default model configurations using Arweave-hosted models.
+ * These work out-of-the-box without any local model files.
+ *
+ * @example
+ * import { MusicClassifier, DEFAULT_ARWEAVE_MODELS } from 'playlist-data-engine';
+ *
+ * const classifier = new MusicClassifier({
+ *     models: DEFAULT_ARWEAVE_MODELS
+ * });
+ */
+export declare const DEFAULT_ARWEAVE_MODELS: {
+    readonly genre: {
+        readonly embedding: "https://arweave.net/tVO0RIu2Ly_Di5cZccw_wB3x6Vs_2KSqxhl8bdhhimE/model.json";
+        readonly classifier: "https://arweave.net/ZY-GSfMe7crJUITAtHITcoLCNfNWVP1HMwywivZ_LAQ/model.json";
+        readonly embeddingType: ModelArchitecture;
+        readonly classifierType: GenreListType;
+    };
+    readonly mood: {
+        readonly embedding: "https://arweave.net/tVO0RIu2Ly_Di5cZccw_wB3x6Vs_2KSqxhl8bdhhimE/model.json";
+        readonly classifier: "https://arweave.net/BUXf3AoFuIsrNDkV2hW6BhiwSVTuFllWOUQv5mu6qQ8/model.json";
+        readonly embeddingType: ModelArchitecture;
+    };
+    readonly danceability: {
+        readonly modelUrl: "https://turbo-gateway.com/nX9KX1OVhEaT1dStNcsRiZKCQTWuHjAMl4MWprIFyZU/model.json";
+        readonly modelType: ModelArchitecture;
+    };
+};
+/**
+ * Registry of genre model presets.
+ * Each preset maps a name to a full ModelConfig with Arweave-hosted URLs.
+ */
+export declare const GENRE_PRESETS: Record<GenrePreset, ModelConfig>;
+/**
+ * Registry of mood model presets.
+ */
+export declare const MOOD_PRESETS: Record<MoodPreset, ModelConfig>;
+/**
+ * Registry of danceability model presets.
+ */
+export declare const DANCEABILITY_PRESETS: Record<DanceabilityPreset, ModelConfig>;
+/**
+ * All available preset names for enumeration.
+ *
+ * @example
+ * import { AVAILABLE_PRESETS } from 'playlist-data-engine';
+ * console.log(AVAILABLE_PRESETS.genre); // ['discogs400', 'jamendo', 'tzanetakis', 'musicnn']
+ */
+export declare const AVAILABLE_PRESETS: {
+    readonly genre: GenrePreset[];
+    readonly mood: MoodPreset[];
+    readonly danceability: DanceabilityPreset[];
+};
+export declare class MusicClassifier {
+    private options;
+    private essentiaWASM;
+    private essentiaModel;
+    private extractor;
+    private initialized;
+    /**
+     * Cache for embedding models by URL.
+     * Key: model URL, Value: initialized model instance
+     * Used to avoid re-loading the same embedding model when shared across
+     * multiple classifiers (e.g., genre and mood using the same discogs-effnet).
+     */
+    private embeddingModelCache;
+    /**
+     * Optional cache for classifier models.
+     * Key: model URL, Value: initialized model instance
+     * Useful when repeatedly analyzing audio with the same classifier.
+     */
+    private classifierModelCache;
+    /**
+     * Cache for resolved Arweave URLs.
+     * Key: original URL, Value: resolved URL (possibly from different gateway)
+     * Avoids repeated gateway resolution calls for the same URL.
+     */
+    private resolvedUrlCache;
+    /**
+     * Architecture-specific feature extractors.
+     * Each architecture requires different mel-band configurations:
+     * - musicnn: 96 bands (default extractor)
+     * - effnet: 128 bands (custom extractor)
+     * - vggish: 64 bands
+     * - tempocnn: 40 bands
+     */
+    private extractors;
+    constructor(options?: MusicClassifierOptions);
+    /**
+     * Initialize essentia.js modules for browser environment.
+     * Must be called before any analysis.
+     */
+    private initializeEssentia;
+    /**
+     * Resolves a URL using the resolveUrl callback with caching.
+     *
+     * If a resolveUrl callback is provided in options, this method will:
+     * 1. Check the cache first to avoid repeated resolution calls
+     * 2. Call the resolveUrl callback if not cached
+     * 3. Cache the result for future use
+     *
+     * If no resolveUrl callback is provided, returns the original URL unchanged.
+     *
+     * @param url - The URL to resolve
+     * @returns Promise resolving to the resolved URL (or original if no resolver)
+     */
+    private resolveUrlWithCache;
+    /**
+     * Loads a TensorFlow.js GraphModel with retry logic for network resilience.
+     *
+     * This method handles transient network failures (common with remote URLs
+     * like Arweave) by retrying with exponential backoff. If a `resolveUrl`
+     * callback is provided in options, it will be called to resolve the URL
+     * before loading (e.g., for Arweave gateway fallback).
+     *
+     * @param modelUrl - URL to the model file
+     * @param maxRetries - Maximum number of retry attempts (default: 3)
+     * @param baseDelayMs - Base delay for exponential backoff in ms (default: 1000)
+     * @returns Promise resolving to the loaded GraphModel
+     */
+    private loadModelWithRetry;
+    /**
+     * Initializes an Essentia model with retry logic for network resilience.
+     *
+     * Essentia models (TensorflowMusiCNN, TensorflowVGGish) have their own
+     * initialize() method that loads the model from URL. This wrapper adds
+     * retry logic similar to loadModelWithRetry.
+     *
+     * @param model - Essentia model instance (TensorflowMusiCNN or TensorflowVGGish)
+     * @param modelUrl - URL to the model file (for logging)
+     * @param maxRetries - Maximum number of retry attempts (default: 3)
+     * @param baseDelayMs - Base delay for exponential backoff in ms (default: 1000)
+     */
+    private initializeEssentiaModelWithRetry;
+    /**
+     * Gets or creates an embedding model instance with caching support.
+     *
+     * This method implements intelligent model caching to avoid re-loading
+     * the same embedding model when it's shared across multiple classifiers
+     * (e.g., genre and mood both using discogs-effnet).
+     *
+     * @param modelUrl - URL to the embedding model
+     * @param explicitType - Optional explicit architecture type (overrides URL detection)
+     * @returns Promise resolving to the initialized model instance
+     */
+    private getEmbeddingModel;
+    /**
+     * Clears the embedding model cache, disposing of any cached models.
+     * Call this to free memory when switching to different models or
+     * when done with analysis.
+     *
+     * Handles both:
+     * - GraphModel instances (effnet) - use dispose()
+     * - Essentia model instances (musicnn, vggish) - use terminate()
+     */
+    clearEmbeddingCache(): void;
+    /**
+     * Clears the classifier model cache, disposing of any cached models.
+     */
+    clearClassifierCache(): void;
+    /**
+     * Clears all model caches (embedding, classifier, and resolved URLs).
+     */
+    clearAllCaches(): void;
+    /**
+     * Computes 128-band mel-spectrogram features for Discogs-EffNet models.
+     *
+     * Unlike the standard musicnn extractor (96 bands), EffNet requires 128 mel bands.
+     * This method uses Essentia WASM's core MelBands algorithm directly.
+     *
+     * @param audioSignal - Mono audio signal at 16kHz sample rate
+     * @returns 2D array of mel-spectrogram frames, shape [frames][128]
+     */
+    /**
+     * Creates a wrapper object that combines EssentiaJS algorithms with WASM utility methods.
+     * This is needed because EssentiaJS has algorithms (Windowing, Spectrum, etc.) but lacks
+     * utility methods like arrayToVector/vectorToArray which are on the WASM module directly.
+     */
+    private createEssentiaWrapper;
+    private computeEffnetFeatures;
+    /**
+     * Gets the appropriate mel-spectrogram features for a given model architecture.
+     *
+     * Different architectures require different mel-band configurations:
+     * - musicnn: 96 bands (default)
+     * - effnet: 128 bands (custom)
+     * - vggish: 64 bands
+     * - tempocnn: 40 bands
+     *
+     * @param audioSignal - Mono audio signal at 16kHz sample rate
+     * @param architecture - The model architecture type
+     * @returns 2D array of mel-spectrogram frames
+     */
+    private getFeaturesForArchitecture;
+    /**
+     * Analyzes audio to extract genre, mood, and vibe data.
+     */
+    analyze(audioUrl: string): Promise<MusicClassificationProfile>;
+    /**
+     * Runs a classifier model on pre-computed embeddings.
+     *
+     * This method is used in the two-step model architecture:
+     * 1. Embedding model produces embeddings from audio features
+     * 2. Classifier model produces class predictions from embeddings
+     *
+     * @param classifierUrl - URL to the classifier model (GraphModel format)
+     * @param embeddings - 2D array of embeddings, shape [frames][embedding_dim]
+     * @returns Promise resolving to 1D array of averaged class predictions
+     */
+    private runClassifierOnEmbeddings;
+    /**
+     * Runs a two-step model architecture prediction.
+     *
+     * This method implements the complete two-step flow:
+     * 1. Detect embedding architecture from config
+     * 2. Extract architecture-specific features (96 vs 128 mel bands!)
+     * 3. Load embedding model (with caching)
+     * 4. Run embedding model to get feature vectors
+     * 5. Run classifier on embeddings
+     * 6. Return predictions
+     *
+     * @param config - Two-step model configuration with embedding and classifier URLs
+     * @param audioSignal - Mono audio signal at 16kHz sample rate
+     * @returns Promise resolving to 1D array of class predictions
+     */
+    private predictWithTwoStepModel;
+    /**
+     * Discovers the input names from a TensorFlow.js GraphModel.
+     *
+     * Different model versions and sources may have different input naming conventions.
+     * This method inspects the model's signature to find the correct input names.
+     *
+     * @param model - TensorFlow.js GraphModel instance
+     * @returns Array of input names expected by the model
+     */
+    private getModelInputNames;
+    /**
+     * Runs effnet embedding model inference on mel-spectrogram features.
+     *
+     * EffNet models are TensorFlow.js GraphModels that expect:
+     * - Named inputs discovered dynamically from model signature
+     * - Mel-spectrogram shape: [batch=64, mel_bands=128, time_frames=96]
+     *
+     * The 'bs64' in model name means fixed batch size of 64.
+     *
+     * @param model - TensorFlow.js GraphModel instance
+     * @param features - 2D array of mel-spectrogram frames, shape [frames][128]
+     * @returns 2D array of embeddings, shape [segments][embedding_dim]
+     */
+    private runEffnetEmbedding;
+    /**
+     * Runs Essentia embedding model inference on mel-spectrogram features.
+     *
+     * This handles TensorflowMusiCNN and TensorflowVGGish models from Essentia.js.
+     * These models have a predict() method that returns frame-level outputs.
+     *
+     * @param model - Essentia model instance (TensorflowMusiCNN or TensorflowVGGish)
+     * @param features - 2D array of mel-spectrogram frames
+     * @returns 2D array of embeddings, shape [frames][embedding_dim]
+     */
+    private runEssentiaEmbedding;
+    /**
+     * Unified model prediction method that handles both single-step and two-step model architectures.
+     *
+     * This is the primary entry point for model predictions. It automatically:
+     * - Detects if the config is single-step or two-step
+     * - Detects the model architecture and uses the correct feature extractor
+     * - Calls the appropriate prediction method
+     * - Maps predictions to labeled ClassificationTags
+     *
+     * @param config - Model configuration (SingleStepModelConfig or TwoStepModelConfig)
+     * @param audioSignal - Mono audio signal at 16kHz sample rate
+     * @param labels - Array of class labels for the model output
+     * @returns Promise resolving to array of ClassificationTags sorted by confidence
+     *
+     * @example
+     * // Single-step prediction
+     * const tags = await classifier.runModelPrediction(
+     *     { modelUrl: '/models/genre-classifier.json', modelType: 'musicnn' },
+     *     audioSignal,
+     *     JAMENDO_GENRES
+     * );
+     *
+     * // Two-step prediction
+     * const tags = await classifier.runModelPrediction(
+     *     { embedding: '/models/effnet.json', classifier: '/models/genre-cls.json' },
+     *     audioSignal,
+     *     JAMENDO_GENRES
+     * );
+     */
+    private runModelPrediction;
+    /**
+     * Run TensorFlow model inference on pre-computed features.
+     */
+    private predictWithModel;
+    private mapPredictions;
+}
+//# sourceMappingURL=MusicClassifier.d.ts.map

package/dist/core/analysis/MusicClassifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MusicClassifier.d.ts","sourceRoot":"","sources":["../../../src/core/analysis/MusicClassifier.ts"],"names":[],"mappings":"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"}