@neuroequality/neuroadapt-ai/dist/advanced/neural-adaptation.d.ts

AI-powered accessibility personalization for neurodivergent users

import { EventEmitter } from 'eventemitter3';

export interface NeuralLayer {
    weights: number[][];
    biases: number[];
    activation: ActivationFunction;
    dropout?: number;
}
export type ActivationFunction = 'relu' | 'sigmoid' | 'tanh' | 'leaky_relu' | 'softmax';
export interface NeuralNetworkConfig {
    layers: number[];
    activations: ActivationFunction[];
    learningRate: number;
    momentum: number;
    regularization: number;
    batchSize: number;
    maxEpochs: number;
    convergenceThreshold: number;
}
export interface TrainingData {
    inputs: number[];
    targets: number[];
    userId: string;
    timestamp: Date;
    context: {
        deviceType: string;
        environment: string;
        timeOfDay: number;
        cognitiveState: number;
    };
}
export interface PredictionResult {
    adaptations: {
        visual: number[];
        cognitive: number[];
        motor: number[];
        sensory: number[];
    };
    confidence: number;
    reasoning: string[];
    alternatives: Array<{
        adaptations: any;
        confidence: number;
    }>;
}
export interface LearningMetrics {
    epoch: number;
    loss: number;
    accuracy: number;
    validationLoss: number;
    validationAccuracy: number;
    learningRate: number;
    convergenceRate: number;
}
/**
 * Neural Adaptation System for real-time accessibility optimization
 */
export declare class NeuralAdaptationSystem extends EventEmitter {
    private config;
    private network;
    private trainingHistory;
    private realtimeBuffer;
    private isTraining;
    private currentEpoch;
    constructor(config?: NeuralNetworkConfig);
    /**
     * Initialize neural network with random weights
     */
    private initializeNetwork;
    /**
     * Forward propagation through the network
     */
    private forward;
    /**
     * Compute output for a single layer
     */
    private computeLayerOutput;
    /**
     * Apply activation function
     */
    private applyActivation;
    /**
     * Backpropagation algorithm
     */
    private backward;
    /**
     * Get activation function derivative
     */
    private getActivationDerivative;
    /**
     * Train the network with batch data
     */
    trainBatch(trainingData: TrainingData[]): Promise<LearningMetrics>;
    /**
     * Train for one epoch
     */
    private trainEpoch;
    /**
     * Train with a single batch of data
     */
    private trainBatchData;
    /**
     * Make prediction for user adaptations
     */
    predict(userId: string, currentContext: any, userHistory: any[]): Promise<PredictionResult>;
    /**
     * Add real-time training data
     */
    addRealtimeData(data: TrainingData): void;
    /**
     * Perform incremental learning with real-time data
     */
    private performIncrementalLearning;
    /**
     * Evaluate network performance
     */
    private evaluateNetwork;
    /**
     * Calculate prediction accuracy
     */
    private calculateAccuracy;
    /**
     * Get total number of parameters in the network
     */
    private getTotalParameters;
    private preprocessInputs;
    private preprocessTargets;
    private createPredictionInputs;
    private parseOutputToAdaptations;
    private calculatePredictionConfidence;
    private generateReasoning;
    private generateAlternatives;
    /**
     * Export network for persistence
     */
    exportNetwork(): any;
    /**
     * Import network from saved state
     */
    importNetwork(data: any): void;
}
export default NeuralAdaptationSystem;
//# sourceMappingURL=neural-adaptation.d.ts.map