Implement adaptive local classifier that learns from user feedback

src/App.css

@@ -147,6 +147,19 @@ header p {
   opacity: 0.6;
 }
 
+.tag.local {
+  background: linear-gradient(45deg, #9b59b6, #8e44ad);
+}
+
+.tag.blended {
+  background: linear-gradient(45deg, #f39c12, #e67e22);
+}
+
+.source-indicator {
+  margin-left: 0.5rem;
+  font-size: 0.8em;
+}
+
 .tag-controls {
   display: flex;
   gap: 0.25rem;

src/App.jsx

@@ -1,6 +1,7 @@
 import { useState, useRef, useEffect } from 'react'
 import CLAPProcessor from './clapProcessor'
 import UserFeedbackStore from './userFeedbackStore'
+import LocalClassifier from './localClassifier'
 import './App.css'
 
 function App() {
@@ -18,11 +19,16 @@ function App() {
   const chunksRef = useRef([])
   const clapProcessorRef = useRef(null)
   const feedbackStoreRef = useRef(null)
+  const localClassifierRef = useRef(null)
 
   useEffect(() => {
     const initializeStore = async () => {
       feedbackStoreRef.current = new UserFeedbackStore()
       await feedbackStoreRef.current.initialize()
+      
+      localClassifierRef.current = new LocalClassifier()
+      localClassifierRef.current.loadModel()
+      
       loadCustomTags()
     }
     initializeStore()
@@ -107,13 +113,53 @@ function App() {
       const generatedTags = await clapProcessorRef.current.processAudio(audioBuffer)
       
       // Store basic audio info for later use
-      setAudioFeatures({
+      const features = {
         sampleRate: audioBuffer.sampleRate,
         duration: audioBuffer.duration,
         numberOfChannels: audioBuffer.numberOfChannels
-      })
+      }
+      setAudioFeatures(features)
+      
+      // Apply local classifier adjustments
+      let finalTags = generatedTags.map(tag => ({ ...tag, userFeedback: null }))
+      
+      if (localClassifierRef.current) {
+        const simpleFeatures = localClassifierRef.current.extractSimpleFeatures(features)
+        const allPossibleTags = [...generatedTags.map(t => t.label), ...customTags]
+        const localPredictions = localClassifierRef.current.predictAll(simpleFeatures, allPossibleTags)
+        
+        // Merge CLAP predictions with local classifier predictions
+        const mergedTags = new Map()
+        
+        // Add CLAP tags
+        for (const tag of generatedTags) {
+          mergedTags.set(tag.label, { ...tag, source: 'clap' })
+        }
+        
+        // Add or adjust with local predictions
+        for (const pred of localPredictions) {
+          if (mergedTags.has(pred.tag)) {
+            // Blend CLAP and local predictions
+            const existing = mergedTags.get(pred.tag)
+            existing.confidence = (existing.confidence + pred.confidence) / 2
+            existing.source = 'blended'
+          } else if (pred.confidence > 0.6) {
+            // Add high-confidence local predictions
+            mergedTags.set(pred.tag, {
+              label: pred.tag,
+              confidence: pred.confidence,
+              source: 'local',
+              userFeedback: null
+            })
+          }
+        }
+        
+        finalTags = Array.from(mergedTags.values())
+          .sort((a, b) => b.confidence - a.confidence)
+          .slice(0, 8) // Keep top 8 tags
+      }
       
-      setTags(generatedTags.map(tag => ({ ...tag, userFeedback: null })))
+      setTags(finalTags)
     } catch (err) {
       console.error('Error processing audio:', err)
       setError('Failed to process audio. Using fallback tags.')
@@ -139,6 +185,17 @@ function App() {
         feedback,
         audioHash
       )
+
+      // Train local classifier on this feedback
+      if (localClassifierRef.current && audioFeatures) {
+        const simpleFeatures = localClassifierRef.current.extractSimpleFeatures(audioFeatures)
+        localClassifierRef.current.trainOnFeedback(
+          simpleFeatures,
+          updatedTags[tagIndex].label,
+          feedback
+        )
+        localClassifierRef.current.saveModel()
+      }
     } catch (error) {
       console.error('Error saving tag feedback:', error)
     }
@@ -151,7 +208,8 @@ function App() {
       label: newTag.trim(), 
       confidence: 1.0, 
       userFeedback: 'custom',
-      isCustom: true 
+      isCustom: true,
+      source: 'custom'
     }
 
     setTags(prev => [...prev, customTag])
@@ -159,6 +217,18 @@ function App() {
     try {
       await feedbackStoreRef.current.saveCustomTag(newTag.trim())
       await feedbackStoreRef.current.saveTagFeedback(newTag.trim(), 'custom', audioHash)
+      
+      // Train local classifier on custom tag
+      if (localClassifierRef.current && audioFeatures) {
+        const simpleFeatures = localClassifierRef.current.extractSimpleFeatures(audioFeatures)
+        localClassifierRef.current.trainOnFeedback(
+          simpleFeatures,
+          newTag.trim(),
+          'custom'
+        )
+        localClassifierRef.current.saveModel()
+      }
+      
       loadCustomTags()
     } catch (error) {
       console.error('Error saving custom tag:', error)
@@ -236,8 +306,11 @@ function App() {
             <div className="tags">
               {tags.map((tag, index) => (
                 <div key={index} className={`tag-item ${tag.userFeedback ? 'has-feedback' : ''}`}>
-                  <span className={`tag ${tag.isCustom ? 'custom' : ''} ${tag.userFeedback === 'negative' ? 'negative' : ''}`}>
+                  <span className={`tag ${tag.isCustom ? 'custom' : ''} ${tag.userFeedback === 'negative' ? 'negative' : ''} ${tag.source || 'clap'}`}>
                     {tag.label} ({Math.round(tag.confidence * 100)}%)
+                    {tag.source === 'local' && <span className="source-indicator">🧠</span>}
+                    {tag.source === 'blended' && <span className="source-indicator">⚡</span>}
+                    {tag.source === 'custom' && <span className="source-indicator">✨</span>}
                   </span>
                   {!tag.isCustom && (
                     <div className="tag-controls">

src/localClassifier.js

@@ -0,0 +1,205 @@
+class LocalClassifier {
+  constructor() {
+    this.weights = new Map(); // tag -> weight vector
+    this.biases = new Map(); // tag -> bias
+    this.learningRate = 0.01;
+    this.featureDim = 512; // CLAP embedding dimension
+    this.isInitialized = false;
+  }
+
+  initialize(featureDim = 512) {
+    this.featureDim = featureDim;
+    this.isInitialized = true;
+  }
+
+  // Simple logistic regression training
+  trainOnFeedback(features, tag, feedback) {
+    if (!this.isInitialized) {
+      this.initialize();
+    }
+
+    // Convert feedback to target value
+    let target;
+    switch (feedback) {
+      case 'positive':
+        target = 1.0;
+        break;
+      case 'negative':
+        target = 0.0;
+        break;
+      case 'custom':
+        target = 1.0;
+        break;
+      default:
+        return; // Skip unknown feedback
+    }
+
+    // Initialize weights for new tag
+    if (!this.weights.has(tag)) {
+      this.weights.set(tag, new Array(this.featureDim).fill(0).map(() => 
+        (Math.random() - 0.5) * 0.01
+      ));
+      this.biases.set(tag, 0);
+    }
+
+    const weights = this.weights.get(tag);
+    const bias = this.biases.get(tag);
+
+    // Forward pass
+    let logit = bias;
+    for (let i = 0; i < features.length; i++) {
+      logit += weights[i] * features[i];
+    }
+
+    // Sigmoid activation
+    const prediction = 1 / (1 + Math.exp(-logit));
+
+    // Compute gradient
+    const error = prediction - target;
+    
+    // Update weights and bias
+    for (let i = 0; i < features.length; i++) {
+      weights[i] -= this.learningRate * error * features[i];
+    }
+    this.biases.set(tag, bias - this.learningRate * error);
+
+    // Store updated weights
+    this.weights.set(tag, weights);
+  }
+
+  // Predict confidence for a tag given features
+  predict(features, tag) {
+    if (!this.weights.has(tag)) {
+      return null; // No training data for this tag
+    }
+
+    const weights = this.weights.get(tag);
+    const bias = this.biases.get(tag);
+
+    let logit = bias;
+    for (let i = 0; i < Math.min(features.length, weights.length); i++) {
+      logit += weights[i] * features[i];
+    }
+
+    // Sigmoid activation
+    return 1 / (1 + Math.exp(-logit));
+  }
+
+  // Get all predictions for given features
+  predictAll(features, candidateTags) {
+    const predictions = [];
+    
+    for (const tag of candidateTags) {
+      const confidence = this.predict(features, tag);
+      if (confidence !== null) {
+        predictions.push({ tag, confidence });
+      }
+    }
+
+    return predictions.sort((a, b) => b.confidence - a.confidence);
+  }
+
+  // Retrain on batch of feedback data
+  retrainOnBatch(feedbackData) {
+    for (const item of feedbackData) {
+      if (item.audioFeatures && item.correctedTags) {
+        // Create simple features from audio metadata
+        const features = this.extractSimpleFeatures(item.audioFeatures);
+        
+        // Train on corrected tags
+        for (const tagData of item.correctedTags) {
+          this.trainOnFeedback(features, tagData.tag, tagData.feedback);
+        }
+      }
+    }
+  }
+
+  // Extract simple features from audio metadata
+  extractSimpleFeatures(audioFeatures) {
+    // Create a simple feature vector from audio metadata
+    // In a real implementation, this would use actual CLAP embeddings
+    const features = new Array(this.featureDim).fill(0);
+    
+    if (audioFeatures) {
+      // Use basic audio properties to create pseudo-features
+      features[0] = audioFeatures.duration / 60; // Duration in minutes
+      features[1] = audioFeatures.sampleRate / 48000; // Normalized sample rate
+      features[2] = audioFeatures.numberOfChannels; // Number of channels
+      
+      // Fill remaining with small random values based on hash of properties
+      const seed = this.simpleHash(JSON.stringify(audioFeatures));
+      for (let i = 3; i < this.featureDim; i++) {
+        features[i] = this.seededRandom(seed + i) * 0.1;
+      }
+    }
+    
+    return features;
+  }
+
+  // Simple hash function for seeded random
+  simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = ((hash << 5) - hash) + char;
+      hash = hash & hash; // Convert to 32-bit integer
+    }
+    return Math.abs(hash);
+  }
+
+  // Seeded random number generator
+  seededRandom(seed) {
+    const x = Math.sin(seed) * 10000;
+    return x - Math.floor(x);
+  }
+
+  // Save model to localStorage
+  saveModel() {
+    const modelData = {
+      weights: Object.fromEntries(this.weights),
+      biases: Object.fromEntries(this.biases),
+      featureDim: this.featureDim,
+      learningRate: this.learningRate
+    };
+    
+    localStorage.setItem('clipTaggerModel', JSON.stringify(modelData));
+  }
+
+  // Load model from localStorage
+  loadModel() {
+    const saved = localStorage.getItem('clipTaggerModel');
+    if (saved) {
+      try {
+        const modelData = JSON.parse(saved);
+        this.weights = new Map(Object.entries(modelData.weights));
+        this.biases = new Map(Object.entries(modelData.biases));
+        this.featureDim = modelData.featureDim || 512;
+        this.learningRate = modelData.learningRate || 0.01;
+        this.isInitialized = true;
+        return true;
+      } catch (error) {
+        console.error('Error loading model:', error);
+      }
+    }
+    return false;
+  }
+
+  // Get model statistics
+  getModelStats() {
+    return {
+      trainedTags: this.weights.size,
+      featureDim: this.featureDim,
+      learningRate: this.learningRate,
+      tags: Array.from(this.weights.keys())
+    };
+  }
+
+  // Clear the model
+  clearModel() {
+    this.weights.clear();
+    this.biases.clear();
+    localStorage.removeItem('clipTaggerModel');
+  }
+}
+
+export default LocalClassifier;