ruv-swarm/src/neural-models/presets/nlp.js

High-performance neural network swarm orchestration in WebAssembly

/**
 * NLP Neural Network Presets
 * Production-ready configurations for natural language processing tasks
 */

export const nlpPresets = {
  // Social Media Sentiment Analysis
  sentiment_analysis_social: {
    name: 'Social Media Sentiment Analyzer',
    description: 'Optimized for real-time sentiment analysis on social media posts',
    model: 'transformer',
    config: {
      dimensions: 512,
      heads: 8,
      layers: 6,
      ffDimensions: 2048,
      vocabSize: 30000,
      maxLength: 280,
      dropoutRate: 0.1,
    },
    training: {
      batchSize: 32,
      learningRate: 5e-5,
      warmupSteps: 1000,
      epochs: 10,
      optimizer: 'adamw',
    },
    performance: {
      expectedAccuracy: '92-94%',
      inferenceTime: '12ms',
      memoryUsage: '512MB',
      trainingTime: '2-3 hours on GPU',
    },
    useCase: 'Twitter, Facebook, Instagram sentiment tracking',
  },

  // Document Summarization
  document_summarization: {
    name: 'Document Summarizer',
    description: 'Extract key information from long documents',
    model: 'transformer',
    config: {
      dimensions: 768,
      heads: 12,
      layers: 12,
      ffDimensions: 3072,
      vocabSize: 50000,
      maxLength: 1024,
      dropoutRate: 0.15,
    },
    training: {
      batchSize: 16,
      learningRate: 3e-5,
      warmupSteps: 2000,
      epochs: 15,
      optimizer: 'adamw',
      gradientAccumulation: 4,
    },
    performance: {
      expectedAccuracy: '88-91%',
      inferenceTime: '45ms',
      memoryUsage: '1.2GB',
      trainingTime: '8-10 hours on GPU',
    },
    useCase: 'News articles, research papers, legal documents',
  },

  // Question Answering
  question_answering: {
    name: 'Question Answering System',
    description: 'Extract answers from context paragraphs',
    model: 'transformer',
    config: {
      dimensions: 768,
      heads: 12,
      layers: 8,
      ffDimensions: 3072,
      vocabSize: 40000,
      maxLength: 512,
      dropoutRate: 0.1,
      includePositionalEmbeddings: true,
    },
    training: {
      batchSize: 24,
      learningRate: 2e-5,
      warmupSteps: 1500,
      epochs: 20,
      optimizer: 'adamw',
    },
    performance: {
      expectedAccuracy: '85-88%',
      inferenceTime: '25ms',
      memoryUsage: '900MB',
      trainingTime: '6-8 hours on GPU',
    },
    useCase: 'Customer support, educational systems, information retrieval',
  },

  // Named Entity Recognition
  named_entity_recognition: {
    name: 'Named Entity Recognizer',
    description: 'Identify and classify named entities in text',
    model: 'lstm',
    config: {
      inputSize: 300,
      hiddenSize: 256,
      numLayers: 2,
      outputSize: 9, // B-PER, I-PER, B-ORG, I-ORG, B-LOC, I-LOC, B-MISC, I-MISC, O
      bidirectional: true,
      returnSequence: true,
      dropoutRate: 0.3,
    },
    training: {
      batchSize: 64,
      learningRate: 1e-3,
      epochs: 30,
      optimizer: 'adam',
      earlyStoppingPatience: 5,
    },
    performance: {
      expectedAccuracy: '91-93%',
      inferenceTime: '8ms',
      memoryUsage: '256MB',
      trainingTime: '3-4 hours on GPU',
    },
    useCase: 'Information extraction, document processing, knowledge graphs',
  },

  // Language Translation
  language_translation: {
    name: 'Neural Machine Translator',
    description: 'Translate between multiple languages',
    model: 'transformer',
    config: {
      dimensions: 512,
      heads: 8,
      layers: 6,
      ffDimensions: 2048,
      vocabSize: 32000,
      maxLength: 256,
      dropoutRate: 0.1,
      shareEmbeddings: true,
    },
    training: {
      batchSize: 128,
      learningRate: 1e-4,
      warmupSteps: 4000,
      epochs: 50,
      optimizer: 'adam',
      labelSmoothing: 0.1,
    },
    performance: {
      expectedAccuracy: '86-89% BLEU',
      inferenceTime: '30ms',
      memoryUsage: '800MB',
      trainingTime: '24-48 hours on GPU',
    },
    useCase: 'Real-time translation, document localization',
  },

  // Text Classification
  text_classification_multi: {
    name: 'Multi-class Text Classifier',
    description: 'Classify text into multiple categories',
    model: 'gru',
    config: {
      inputSize: 300,
      hiddenSize: 256,
      numLayers: 3,
      outputSize: 20, // Number of classes
      bidirectional: true,
      dropoutRate: 0.4,
      returnSequence: false,
    },
    training: {
      batchSize: 128,
      learningRate: 1e-3,
      epochs: 25,
      optimizer: 'adam',
      classWeights: 'balanced',
    },
    performance: {
      expectedAccuracy: '89-92%',
      inferenceTime: '6ms',
      memoryUsage: '384MB',
      trainingTime: '2-3 hours on GPU',
    },
    useCase: 'Email categorization, content moderation, topic classification',
  },

  // Conversational AI
  conversational_ai: {
    name: 'Conversational AI Model',
    description: 'Generate contextual responses in conversations',
    model: 'transformer',
    config: {
      dimensions: 768,
      heads: 12,
      layers: 10,
      ffDimensions: 3072,
      vocabSize: 50000,
      maxLength: 512,
      dropoutRate: 0.1,
      useMemory: true,
    },
    training: {
      batchSize: 16,
      learningRate: 2e-5,
      warmupSteps: 2000,
      epochs: 30,
      optimizer: 'adamw',
      useReinforcementLearning: true,
    },
    performance: {
      expectedAccuracy: '87-90%',
      inferenceTime: '40ms',
      memoryUsage: '1.5GB',
      trainingTime: '48-72 hours on GPU',
    },
    useCase: 'Chatbots, virtual assistants, customer service',
  },

  // Code Generation
  code_generation: {
    name: 'Code Generator',
    description: 'Generate code from natural language descriptions',
    model: 'transformer',
    config: {
      dimensions: 1024,
      heads: 16,
      layers: 12,
      ffDimensions: 4096,
      vocabSize: 64000,
      maxLength: 2048,
      dropoutRate: 0.1,
      useRotaryPositionalEmbedding: true,
    },
    training: {
      batchSize: 8,
      learningRate: 1e-5,
      warmupSteps: 5000,
      epochs: 20,
      optimizer: 'adamw',
      gradientAccumulation: 8,
    },
    performance: {
      expectedAccuracy: '78-82%',
      inferenceTime: '100ms',
      memoryUsage: '3GB',
      trainingTime: '5-7 days on GPU',
    },
    useCase: 'Code completion, bug fixing, code documentation',
  },

  // Semantic Search
  semantic_search: {
    name: 'Semantic Search Engine',
    description: 'Find semantically similar content',
    model: 'transformer',
    config: {
      dimensions: 768,
      heads: 12,
      layers: 6,
      ffDimensions: 3072,
      vocabSize: 30000,
      maxLength: 512,
      dropoutRate: 0.1,
      poolingStrategy: 'mean',
    },
    training: {
      batchSize: 32,
      learningRate: 2e-5,
      warmupSteps: 1000,
      epochs: 10,
      optimizer: 'adamw',
      useContrastiveLoss: true,
    },
    performance: {
      expectedAccuracy: '91-93%',
      inferenceTime: '15ms',
      memoryUsage: '800MB',
      trainingTime: '12-16 hours on GPU',
    },
    useCase: 'Document retrieval, FAQ systems, knowledge bases',
  },

  // Grammar Correction
  grammar_correction: {
    name: 'Grammar and Style Corrector',
    description: 'Detect and correct grammatical errors',
    model: 'transformer',
    config: {
      dimensions: 512,
      heads: 8,
      layers: 6,
      ffDimensions: 2048,
      vocabSize: 40000,
      maxLength: 256,
      dropoutRate: 0.15,
    },
    training: {
      batchSize: 64,
      learningRate: 3e-5,
      warmupSteps: 1500,
      epochs: 15,
      optimizer: 'adamw',
      useDataAugmentation: true,
    },
    performance: {
      expectedAccuracy: '93-95%',
      inferenceTime: '20ms',
      memoryUsage: '600MB',
      trainingTime: '8-10 hours on GPU',
    },
    useCase: 'Writing assistants, educational tools, content editing',
  },
};

// Export utility function to get preset by name
export const getNLPPreset = (presetName) => {
  if (!nlpPresets[presetName]) {
    throw new Error(`NLP preset '${presetName}' not found. Available presets: ${Object.keys(nlpPresets).join(', ')}`);
  }
  return nlpPresets[presetName];
};

// Export list of available presets
export const availableNLPPresets = Object.keys(nlpPresets);