AsterMind-ELM Premium Documentation

Overview

AsterMind Premium extends AsterMind Pro and AsterMind ELM with 21 advanced ELM variants designed for enterprise use cases. Premium includes all features from Pro (RAG, Reranking, Summarization, Information Flow Analysis) plus specialized ELM architectures for:

• • Online/Streaming Learning: Adaptive and Forgetting Online ELM
• • Hierarchical Classification: Multi-level decision trees
• • Attention Mechanisms: Attention-Enhanced ELM
• • Uncertainty Quantification: Variational ELM
• • Time-Series Analysis: Time-Series ELM
• • Transfer Learning: Pre-trained model adaptation
• • Graph Neural Networks: Graph ELM and Graph Kernel ELM
• • Kernel Methods: 8 specialized kernel ELM variants
• • Deep Architectures: Deep Kernel ELM
• • Convolutional & Recurrent: CNN and RNN-style ELM
• • Fuzzy Logic: Fuzzy ELM
• • Quantum-Inspired: Quantum-Inspired ELM
• • Tensor Operations: Tensor Kernel ELM

Installation

npm install @astermind/astermind-premium

Peer Dependencies

AsterMind Premium requires:

• @astermind/astermind-pro (automatically installed as a dependency)
• @astermind/astermind-elm (included via Pro)

License Setup

AsterMind Premium requires a valid license token to use premium features.

Getting Your License Key

To get started with AsterMind Premium, visit our getting started page:

The getting started page provides step-by-step instructions for:

• Creating a free trial account
• Obtaining your license token
• Setting up your development environment

Setting Your License

Option 1: Environment Variable (Recommended)

export ASTERMIND_LICENSE_TOKEN="your-license-token-here"

Option 2: Programmatic Setup

import { setLicenseTokenFromString, initializeLicense } from '@astermind/astermind-premium';

// Initialize license system
initializeLicense();

// Set your license token
await setLicenseTokenFromString('your-license-token-here');

Option 3: Configuration File

// src/config/license-config.ts
export const LICENSE_TOKEN = 'your-license-token-here';

Quick Start

import { 
  AdaptiveOnlineELM,
  HierarchicalELM,
  VariationalELM,
  initializeLicense,
  setLicenseTokenFromString
} from '@astermind/astermind-premium';

// Initialize license
await initializeLicense();
await setLicenseTokenFromString(process.env.ASTERMIND_LICENSE_TOKEN);

// Use Adaptive Online ELM for streaming data
const model = new AdaptiveOnlineELM({
  categories: ['positive', 'negative', 'neutral'],
  initialHiddenUnits: 64
});

// Train on batch data
const X = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
const y = [0, 1, 0];
model.fit(X, y);

// Predict
const predictions = model.predict([1, 2, 3], 3);
console.log(predictions);

Premium ELM Variants

import { AdaptiveOnlineELM } from '@astermind/astermind-premium';

const model = new AdaptiveOnlineELM({
  categories: ['class1', 'class2'],
  initialHiddenUnits: 64,
  minHiddenUnits: 32,
  maxHiddenUnits: 256
});

// Batch training
model.fit(X, y);

// Online updates
model.update(newSample, newLabel);

import { ForgettingOnlineELM } from '@astermind/astermind-premium';

const model = new ForgettingOnlineELM({
  categories: ['class1', 'class2'],
  forgettingFactor: 0.95 // Higher = forgets slower
});

model.fit(X, y);
model.update(newSample, newLabel);

import { HierarchicalELM } from '@astermind/astermind-premium';

const model = new HierarchicalELM({
  hierarchy: {
    'root': ['animal', 'plant'],
    'animal': ['mammal', 'bird'],
    'mammal': ['dog', 'cat']
  },
  rootCategories: ['root']
});

model.train(X, y.map(label => getHierarchicalPath(label)));
const predictions = model.predict(sample, 3);
// Returns: [{ path: ['root', 'animal', 'mammal', 'dog'], prob: 0.95 }]

import { AttentionEnhancedELM } from '@astermind/astermind-premium';

const model = new AttentionEnhancedELM({
  categories: ['class1', 'class2'],
  attentionUnits: 128
});

model.train(X, y);
const predictions = model.predict(sample, 3);

import { VariationalELM } from '@astermind/astermind-premium';

const model = new VariationalELM({
  categories: ['class1', 'class2']
});

model.train(X, y);
const predictions = model.predict(sample, 3, true); // Include uncertainty
// Returns: [{ label: 'class1', prob: 0.9, uncertainty: 0.05, confidence: 0.95 }]

import { TimeSeriesELM } from '@astermind/astermind-premium';

const model = new TimeSeriesELM({
  categories: ['trend_up', 'trend_down', 'stable'],
  sequenceLength: 10
});

// Sequences: number[][][] - array of sequences, each sequence is number[][]
const sequences = [
  [[1, 2], [2, 3], [3, 4]], // Sequence 1
  [[5, 6], [6, 7], [7, 8]]  // Sequence 2
];
const labels = [0, 1];

model.train(sequences, labels);
const prediction = model.predict(sequences[0], 3);

import { TransferLearningELM } from '@astermind/astermind-premium';

const model = new TransferLearningELM({
  categories: ['new_class1', 'new_class2'],
  transferRate: 0.3 // How much to adapt from source
});

model.train(X, y);

import { GraphELM } from '@astermind/astermind-premium';

const model = new GraphELM({
  categories: ['type1', 'type2']
});

const graphs = [
  {
    nodes: [
      { id: 'n1', features: [1, 2, 3] },
      { id: 'n2', features: [4, 5, 6] }
    ],
    edges: [
      { source: 'n1', target: 'n2' }
    ]
  }
];
const labels = [0];

model.train(graphs, labels);
const prediction = model.predict(graphs[0], 3);

import { AdaptiveKernelELM } from '@astermind/astermind-premium';

const model = new AdaptiveKernelELM({
  categories: ['class1', 'class2'],
  kernelType: 'rbf' // 'rbf', 'polynomial', 'sigmoid'
});

model.train(X, y);

import { SparseKernelELM } from '@astermind/astermind-premium';

const model = new SparseKernelELM({
  categories: ['class1', 'class2'],
  numLandmarks: 50 // Number of landmark points
});

model.train(X, y);

import { EnsembleKernelELM } from '@astermind/astermind-premium';

const model = new EnsembleKernelELM({
  categories: ['class1', 'class2'],
  numModels: 5 // Number of ensemble members
});

model.train(X, y);
const predictions = model.predict(sample, 3);
// Returns: [{ label: 'class1', prob: 0.9, votes: 4 }] // votes = ensemble agreement

import { DeepKernelELM } from '@astermind/astermind-premium';

const model = new DeepKernelELM({
  categories: ['class1', 'class2'],
  numLayers: 3
});

model.train(X, y);

import { RobustKernelELM } from '@astermind/astermind-premium';

const model = new RobustKernelELM({
  categories: ['class1', 'class2'],
  outlierThreshold: 0.1
});

model.train(X, y);
const predictions = model.predict(sample, 3);
// Returns: [{ label: 'class1', prob: 0.9, isOutlier: false }]

import { ELMKELMCascade } from '@astermind/astermind-premium';

const model = new ELMKELMCascade({
  categories: ['class1', 'class2']
});

model.train(X, y);

import { StringKernelELM } from '@astermind/astermind-premium';

const model = new StringKernelELM({
  categories: ['positive', 'negative']
});

const strings = ['hello world', 'good morning', 'bad day'];
const labels = [0, 0, 1];

model.train(strings, labels);
const prediction = model.predict(['hello'], 3);

import { ConvolutionalELM } from '@astermind/astermind-premium';

const model = new ConvolutionalELM({
  categories: ['cat', 'dog'],
  filterSize: 3,
  numFilters: 16
});

// Images: number[][][] - array of 2D images
const images = [
  [[1, 2, 3], [4, 5, 6], [7, 8, 9]], // Image 1
  [[9, 8, 7], [6, 5, 4], [3, 2, 1]]  // Image 2
];
const labels = [0, 1];

model.train(images, labels);
const prediction = model.predict(images[0], 3);

import { RecurrentELM } from '@astermind/astermind-premium';

const model = new RecurrentELM({
  categories: ['class1', 'class2'],
  hiddenSize: 64
});

const sequences = [
  [[1, 2], [2, 3], [3, 4]], // Sequence 1
  [[5, 6], [6, 7], [7, 8]]  // Sequence 2
];
const labels = [0, 1];

model.train(sequences, labels);
const predictions = model.predict(sequences[0], 3);
// Returns: [{ label: 'class1', prob: 0.9, hiddenState: [...] }]

import { FuzzyELM } from '@astermind/astermind-premium';

const model = new FuzzyELM({
  categories: ['low', 'medium', 'high']
});

model.train(X, y);
const predictions = model.predict(sample, 3);
// Returns: [{ label: 'medium', prob: 0.8, membership: 0.85, confidence: 0.9 }]

import { QuantumInspiredELM } from '@astermind/astermind-premium';

const model = new QuantumInspiredELM({
  categories: ['class1', 'class2'],
  numQubits: 8
});

model.train(X, y);
const predictions = model.predict(sample, 3);
// Returns: [{ label: 'class1', prob: 0.9, quantumState: [...], amplitude: 0.95 }]

import { GraphKernelELM } from '@astermind/astermind-premium';

const model = new GraphKernelELM({
  categories: ['type1', 'type2']
});

const graphs = [
  {
    nodes: [{ id: 'n1', features: [1, 2] }],
    edges: [{ source: 'n1', target: 'n2' }]
  }
];
const labels = [0];

model.train(graphs, labels);

import { TensorKernelELM } from '@astermind/astermind-premium';

const model = new TensorKernelELM({
  categories: ['class1', 'class2']
});

// Tensors: number[][][] - array of 3D tensors
const tensors = [
  [
    [[1, 2], [3, 4]], // Channel 1
    [[5, 6], [7, 8]]  // Channel 2
  ]
];
const labels = [0];

model.train(tensors, labels);
const prediction = model.predict(tensors[0], 3);

API Reference

License Management

Common ELM Interface

All Premium ELM variants follow a similar interface:

interface ELMConfig {
  categories: string[];
  // ... variant-specific options
}

class PremiumELM {
  constructor(config: ELMConfig);
  train(X: any[], y: number[]): void;
  predict(sample: any, topK?: number): Prediction[];
}

Integration with AsterMind Pro

Premium includes all features from AsterMind Pro:

• RAG (Retrieval-Augmented Generation)
• Reranking
• Summarization
• Information Flow Analysis
• All Pro ELM variants

import { 
  RAGPipeline,
  Reranker,
  Summarizer,
  AdaptiveOnlineELM // Premium variant
} from '@astermind/astermind-premium';

Related Packages

• AsterMind Pro- Advanced ML toolkit with RAG, reranking, and more
• AsterMind ELM- Core Extreme Learning Machine library
• AsterMind Synthetic Data- Synthetic data generation