@nice2dev/ui-tools 1.0.10

package/dist/model-training.d.ts

@@ -0,0 +1,706 @@
+/**
+ * @file model-training.ts
+ * @module @nice2dev/ui-tools
+ * @description PRO-18.2 — Model Training UI
+ *
+ * Types for ML model training: experiment tracking, hyperparameter tuning,
+ * metrics visualization, distributed training, AutoML.
+ */
+/** ML framework */
+export type MLFramework = 'pytorch' | 'tensorflow' | 'keras' | 'jax' | 'sklearn' | 'xgboost' | 'lightgbm' | 'catboost' | 'huggingface' | 'custom';
+/** Training status */
+export type TrainingStatus = 'pending' | 'initializing' | 'running' | 'paused' | 'completed' | 'failed' | 'cancelled' | 'killed';
+/** Metric type */
+export type MetricType = 'loss' | 'accuracy' | 'precision' | 'recall' | 'f1' | 'auc' | 'mse' | 'mae' | 'rmse' | 'r2' | 'bleu' | 'rouge' | 'perplexity' | 'custom';
+/** Optimization direction */
+export type OptimizationDirection = 'minimize' | 'maximize';
+/** ML training config */
+export interface MLTrainingConfig {
+    /** Theme */
+    theme?: TrainingTheme;
+    /** Features */
+    features?: TrainingFeatures;
+    /** Tracking backend */
+    tracking?: TrackingConfig;
+    /** Compute config */
+    compute?: ComputeConfig;
+    /** Notification config */
+    notifications?: TrainingNotificationConfig;
+}
+/** Training theme */
+export interface TrainingTheme {
+    name?: string;
+    colors?: TrainingColors;
+    chartTheme?: 'light' | 'dark';
+}
+/** Training colors */
+export interface TrainingColors {
+    primary?: string;
+    success?: string;
+    warning?: string;
+    error?: string;
+    metricColors?: string[];
+}
+/** Training features */
+export interface TrainingFeatures {
+    experimentTracking?: boolean;
+    hyperparameterTuning?: boolean;
+    distributedTraining?: boolean;
+    autoML?: boolean;
+    modelComparison?: boolean;
+    checkpointing?: boolean;
+    profiling?: boolean;
+    liveMetrics?: boolean;
+}
+/** Tracking config */
+export interface TrackingConfig {
+    backend: TrackingBackend;
+    uri?: string;
+    experiment?: string;
+    apiKey?: string;
+    projectId?: string;
+}
+/** Tracking backend */
+export type TrackingBackend = 'mlflow' | 'wandb' | 'tensorboard' | 'neptune' | 'comet' | 'clearml' | 'aim' | 'custom';
+/** Compute config */
+export interface ComputeConfig {
+    provider: ComputeProvider;
+    instanceType?: string;
+    gpuCount?: number;
+    gpuType?: string;
+    maxRuntime?: number;
+    spot?: boolean;
+}
+/** Compute provider */
+export type ComputeProvider = 'local' | 'aws_sagemaker' | 'gcp_vertex' | 'azure_ml' | 'databricks' | 'kubernetes' | 'custom';
+/** Training notification config */
+export interface TrainingNotificationConfig {
+    onComplete?: boolean;
+    onFail?: boolean;
+    onMetricThreshold?: MetricThreshold[];
+    channels?: NotificationChannel[];
+}
+/** Metric threshold */
+export interface MetricThreshold {
+    metric: string;
+    condition: 'above' | 'below';
+    value: number;
+}
+/** Notification channel */
+export interface NotificationChannel {
+    type: 'email' | 'slack' | 'webhook';
+    config: Record<string, unknown>;
+}
+/** Experiment */
+export interface Experiment {
+    id: string;
+    name: string;
+    description?: string;
+    project?: string;
+    runs: ExperimentRun[];
+    tags?: string[];
+    metadata?: ExperimentMetadata;
+    createdAt: Date;
+    createdBy?: string;
+}
+/** Experiment run */
+export interface ExperimentRun {
+    id: string;
+    name?: string;
+    experimentId: string;
+    status: TrainingStatus;
+    config: RunConfig;
+    metrics?: RunMetrics;
+    artifacts?: RunArtifact[];
+    checkpoints?: Checkpoint[];
+    logs?: LogEntry[];
+    systemMetrics?: SystemMetrics;
+    parent?: string;
+    tags?: string[];
+    notes?: string;
+    startTime?: Date;
+    endTime?: Date;
+    duration?: number;
+}
+/** Run config */
+export interface RunConfig {
+    model: ModelConfig;
+    training: TrainingParams;
+    data: DataConfig;
+    environment?: EnvironmentConfig;
+    hyperparameters?: Record<string, unknown>;
+}
+/** Model config */
+export interface ModelConfig {
+    name: string;
+    framework: MLFramework;
+    architecture?: string;
+    pretrained?: string;
+    parameters?: number;
+    config?: Record<string, unknown>;
+}
+/** Training params */
+export interface TrainingParams {
+    epochs: number;
+    batchSize: number;
+    learningRate: number;
+    optimizer: OptimizerConfig;
+    scheduler?: SchedulerConfig;
+    lossFunction?: string;
+    metrics?: string[];
+    seed?: number;
+    earlyStopping?: EarlyStoppingConfig;
+    gradientClipping?: number;
+    mixedPrecision?: boolean;
+    gradientAccumulation?: number;
+}
+/** Optimizer config */
+export interface OptimizerConfig {
+    name: string;
+    params?: Record<string, unknown>;
+}
+/** Scheduler config */
+export interface SchedulerConfig {
+    name: string;
+    params?: Record<string, unknown>;
+}
+/** Early stopping config */
+export interface EarlyStoppingConfig {
+    metric: string;
+    patience: number;
+    minDelta?: number;
+    mode: OptimizationDirection;
+}
+/** Data config */
+export interface DataConfig {
+    datasetId?: string;
+    trainPath?: string;
+    valPath?: string;
+    testPath?: string;
+    preprocessing?: PreprocessingConfig;
+    augmentation?: string;
+}
+/** Preprocessing config */
+export interface PreprocessingConfig {
+    normalize?: boolean;
+    resize?: number[];
+    tokenizer?: string;
+    maxLength?: number;
+    [key: string]: unknown;
+}
+/** Environment config */
+export interface EnvironmentConfig {
+    pythonVersion?: string;
+    framework?: string;
+    frameworkVersion?: string;
+    cuda?: string;
+    cudnn?: string;
+    packages?: PackageVersion[];
+    docker?: string;
+}
+/** Package version */
+export interface PackageVersion {
+    name: string;
+    version: string;
+}
+/** Run metrics */
+export interface RunMetrics {
+    train: MetricHistory;
+    val?: MetricHistory;
+    test?: MetricHistory;
+    best?: BestMetrics;
+    final?: Record<string, number>;
+}
+/** Metric history */
+export interface MetricHistory {
+    epochs: number[];
+    steps?: number[];
+    metrics: Record<string, number[]>;
+}
+/** Best metrics */
+export interface BestMetrics {
+    epoch: number;
+    step?: number;
+    metrics: Record<string, number>;
+}
+/** Run artifact */
+export interface RunArtifact {
+    id: string;
+    name: string;
+    type: ArtifactType;
+    path: string;
+    size?: number;
+    checksum?: string;
+    metadata?: Record<string, unknown>;
+    createdAt: Date;
+}
+/** Artifact type */
+export type ArtifactType = 'model' | 'checkpoint' | 'config' | 'logs' | 'metrics' | 'dataset' | 'plot' | 'report' | 'custom';
+/** Checkpoint */
+export interface Checkpoint {
+    id: string;
+    epoch: number;
+    step?: number;
+    metrics: Record<string, number>;
+    path: string;
+    size?: number;
+    best?: boolean;
+    createdAt: Date;
+}
+/** Log entry */
+export interface LogEntry {
+    timestamp: Date;
+    level: 'debug' | 'info' | 'warning' | 'error';
+    message: string;
+    source?: string;
+    metadata?: Record<string, unknown>;
+}
+/** System metrics */
+export interface SystemMetrics {
+    timestamps: Date[];
+    cpu: number[];
+    memory: number[];
+    gpu?: GPUMetrics[];
+    disk?: DiskMetrics;
+    network?: NetworkMetrics;
+}
+/** GPU metrics */
+export interface GPUMetrics {
+    id: number;
+    name?: string;
+    utilization: number[];
+    memory: number[];
+    temperature?: number[];
+    power?: number[];
+}
+/** Disk metrics */
+export interface DiskMetrics {
+    read: number[];
+    write: number[];
+}
+/** Network metrics */
+export interface NetworkMetrics {
+    sent: number[];
+    received: number[];
+}
+/** Experiment metadata */
+export interface ExperimentMetadata {
+    goal?: string;
+    dataset?: string;
+    baseline?: string;
+    custom?: Record<string, unknown>;
+}
+/** Hyperparameter sweep */
+export interface HyperparameterSweep {
+    id: string;
+    name: string;
+    experimentId: string;
+    status: SweepStatus;
+    config: SweepConfig;
+    trials: SweepTrial[];
+    bestTrial?: SweepTrial;
+    analysis?: SweepAnalysis;
+    createdAt: Date;
+    completedAt?: Date;
+}
+/** Sweep status */
+export type SweepStatus = 'pending' | 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
+/** Sweep config */
+export interface SweepConfig {
+    method: SweepMethod;
+    metric: SweepMetric;
+    parameters: HyperparameterSpace;
+    maxTrials?: number;
+    maxConcurrent?: number;
+    earlyTermination?: EarlyTerminationConfig;
+    scheduler?: TrialScheduler;
+}
+/** Sweep method */
+export type SweepMethod = 'grid' | 'random' | 'bayesian' | 'hyperband' | 'bohb' | 'pbt' | 'optuna' | 'custom';
+/** Sweep metric */
+export interface SweepMetric {
+    name: string;
+    goal: OptimizationDirection;
+}
+/** Hyperparameter space */
+export interface HyperparameterSpace {
+    [name: string]: HyperparameterDef;
+}
+/** Hyperparameter definition */
+export interface HyperparameterDef {
+    type: HyperparameterType;
+    values?: unknown[];
+    min?: number;
+    max?: number;
+    step?: number;
+    logScale?: boolean;
+    distribution?: Distribution;
+    conditional?: ConditionalParam;
+}
+/** Hyperparameter type */
+export type HyperparameterType = 'categorical' | 'uniform' | 'loguniform' | 'int' | 'float' | 'choice' | 'constant';
+/** Distribution */
+export type Distribution = 'uniform' | 'loguniform' | 'normal' | 'lognormal' | 'discrete';
+/** Conditional param */
+export interface ConditionalParam {
+    parent: string;
+    condition: 'equals' | 'in' | 'greater' | 'less';
+    value: unknown;
+}
+/** Early termination config */
+export interface EarlyTerminationConfig {
+    type: 'median' | 'percentile' | 'threshold';
+    evaluationInterval?: number;
+    delayEvaluation?: number;
+    slackFactor?: number;
+    percentile?: number;
+    threshold?: number;
+}
+/** Trial scheduler */
+export interface TrialScheduler {
+    type: 'asha' | 'hyperband' | 'pbt' | 'median_stopping';
+    config?: Record<string, unknown>;
+}
+/** Sweep trial */
+export interface SweepTrial {
+    id: string;
+    sweepId: string;
+    runId?: string;
+    number: number;
+    status: TrialStatus;
+    hyperparameters: Record<string, unknown>;
+    metrics?: Record<string, number>;
+    intermediateMetrics?: IntermediateMetric[];
+    startTime?: Date;
+    endTime?: Date;
+    duration?: number;
+    error?: string;
+}
+/** Trial status */
+export type TrialStatus = 'pending' | 'running' | 'completed' | 'pruned' | 'failed';
+/** Intermediate metric */
+export interface IntermediateMetric {
+    step: number;
+    value: number;
+}
+/** Sweep analysis */
+export interface SweepAnalysis {
+    parameterImportance: ParameterImportance[];
+    parallelCoordinates: ParallelCoordinatesData;
+    optHistory: OptimizationHistory;
+    contourPlots?: ContourPlot[];
+}
+/** Parameter importance */
+export interface ParameterImportance {
+    name: string;
+    importance: number;
+    method: 'fanova' | 'permutation' | 'shap';
+}
+/** Parallel coordinates data */
+export interface ParallelCoordinatesData {
+    dimensions: string[];
+    values: number[][];
+    colors: number[];
+}
+/** Optimization history */
+export interface OptimizationHistory {
+    trials: number[];
+    values: number[];
+    best: number[];
+}
+/** Contour plot */
+export interface ContourPlot {
+    xParam: string;
+    yParam: string;
+    zValues: number[][];
+    xRange: number[];
+    yRange: number[];
+}
+/** Model comparison */
+export interface ModelComparison {
+    id: string;
+    name: string;
+    runs: string[];
+    metrics: ComparisonMetric[];
+    charts?: ComparisonChart[];
+    summary?: ComparisonSummary;
+    createdAt: Date;
+}
+/** Comparison metric */
+export interface ComparisonMetric {
+    name: string;
+    values: Record<string, number>;
+    best: string;
+    worst: string;
+    mean?: number;
+    std?: number;
+}
+/** Comparison chart */
+export interface ComparisonChart {
+    type: 'bar' | 'line' | 'radar' | 'scatter';
+    metric: string;
+    data: ChartDataPoint[];
+}
+/** Chart data point */
+export interface ChartDataPoint {
+    runId: string;
+    runName?: string;
+    value: number;
+    epoch?: number;
+}
+/** Comparison summary */
+export interface ComparisonSummary {
+    winner: string;
+    scores: Record<string, number>;
+    analysis?: string;
+}
+/** Distributed config */
+export interface DistributedConfig {
+    strategy: DistributedStrategy;
+    nodes?: number;
+    gpusPerNode?: number;
+    backend?: DistributedBackend;
+    config?: StrategyConfig;
+}
+/** Distributed strategy */
+export type DistributedStrategy = 'ddp' | 'fsdp' | 'deepspeed' | 'horovod' | 'mirroredStrategy' | 'multiWorker' | 'parameterServer';
+/** Distributed backend */
+export type DistributedBackend = 'nccl' | 'gloo' | 'mpi';
+/** Strategy config */
+export interface StrategyConfig {
+    stage?: number;
+    offloadOptimizer?: boolean;
+    offloadParams?: boolean;
+    shardingStrategy?: string;
+    cpuOffload?: boolean;
+    gradientAsyncUpdates?: boolean;
+    localSgd?: boolean;
+    localSgdFreq?: number;
+    [key: string]: unknown;
+}
+/** Distributed job */
+export interface DistributedJob {
+    id: string;
+    runId: string;
+    config: DistributedConfig;
+    workers: WorkerInfo[];
+    status: TrainingStatus;
+    progress?: DistributedProgress;
+}
+/** Worker info */
+export interface WorkerInfo {
+    id: string;
+    rank: number;
+    hostname?: string;
+    gpus?: number[];
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    metrics?: SystemMetrics;
+}
+/** Distributed progress */
+export interface DistributedProgress {
+    epoch: number;
+    step: number;
+    totalSteps: number;
+    throughput?: number;
+    syncTime?: number;
+}
+/** AutoML job */
+export interface AutoMLJob {
+    id: string;
+    name: string;
+    status: AutoMLStatus;
+    config: AutoMLConfig;
+    trials: AutoMLTrial[];
+    bestModel?: AutoMLModel;
+    leaderboard?: AutoMLLeaderboard;
+    report?: AutoMLReport;
+    startTime?: Date;
+    endTime?: Date;
+}
+/** AutoML status */
+export type AutoMLStatus = 'pending' | 'preprocessing' | 'searching' | 'training' | 'evaluating' | 'completed' | 'failed';
+/** AutoML config */
+export interface AutoMLConfig {
+    task: AutoMLTask;
+    dataset: AutoMLDataset;
+    metric: string;
+    timeLimit?: number;
+    maxModels?: number;
+    searchSpace?: AutoMLSearchSpace;
+    preprocessing?: AutoMLPreprocessing;
+    validation?: AutoMLValidation;
+}
+/** AutoML task */
+export type AutoMLTask = 'classification' | 'regression' | 'timeSeries' | 'objectDetection' | 'textClassification' | 'tabular';
+/** AutoML dataset */
+export interface AutoMLDataset {
+    trainPath: string;
+    targetColumn: string;
+    features?: string[];
+    testPath?: string;
+}
+/** AutoML search space */
+export interface AutoMLSearchSpace {
+    algorithms?: string[];
+    preprocessing?: string[];
+    featureEngineering?: boolean;
+    ensembling?: boolean;
+}
+/** AutoML preprocessing */
+export interface AutoMLPreprocessing {
+    handleMissing?: 'drop' | 'impute';
+    handleCategorical?: 'onehot' | 'label' | 'target';
+    handleOutliers?: boolean;
+    featureScaling?: boolean;
+}
+/** AutoML validation */
+export interface AutoMLValidation {
+    strategy: 'holdout' | 'cv' | 'timeseries';
+    splits?: number;
+    testSize?: number;
+}
+/** AutoML trial */
+export interface AutoMLTrial {
+    id: string;
+    algorithm: string;
+    hyperparameters: Record<string, unknown>;
+    preprocessing?: Record<string, unknown>;
+    metrics: Record<string, number>;
+    trainingTime: number;
+    status: TrialStatus;
+}
+/** AutoML model */
+export interface AutoMLModel {
+    trialId: string;
+    algorithm: string;
+    metrics: Record<string, number>;
+    featureImportance?: FeatureImportance[];
+    path?: string;
+}
+/** Feature importance */
+export interface FeatureImportance {
+    feature: string;
+    importance: number;
+}
+/** AutoML leaderboard */
+export interface AutoMLLeaderboard {
+    metric: string;
+    entries: LeaderboardEntry[];
+}
+/** Leaderboard entry */
+export interface LeaderboardEntry {
+    rank: number;
+    trialId: string;
+    algorithm: string;
+    score: number;
+    trainingTime: number;
+}
+/** AutoML report */
+export interface AutoMLReport {
+    dataProfile: DataProfile;
+    modelSelection: ModelSelectionReport;
+    featureAnalysis: FeatureAnalysisReport;
+    recommendations: string[];
+}
+/** Data profile */
+export interface DataProfile {
+    rows: number;
+    features: number;
+    targetDistribution: Record<string, number>;
+    missingValues: Record<string, number>;
+    correlations?: number[][];
+}
+/** Model selection report */
+export interface ModelSelectionReport {
+    trialsRun: number;
+    bestAlgorithm: string;
+    algorithmComparison: AlgorithmComparison[];
+}
+/** Algorithm comparison */
+export interface AlgorithmComparison {
+    algorithm: string;
+    trials: number;
+    bestScore: number;
+    avgScore: number;
+    avgTime: number;
+}
+/** Feature analysis report */
+export interface FeatureAnalysisReport {
+    importantFeatures: FeatureImportance[];
+    redundantFeatures: string[];
+    suggestedFeatures?: string[];
+}
+/** Training profile */
+export interface TrainingProfile {
+    runId: string;
+    timeline: ProfileTimeline;
+    memoryProfile?: MemoryProfile;
+    computeProfile?: ComputeProfile;
+    ioProfile?: IOProfile;
+    bottlenecks?: Bottleneck[];
+}
+/** Profile timeline */
+export interface ProfileTimeline {
+    events: ProfileEvent[];
+    totalTime: number;
+}
+/** Profile event */
+export interface ProfileEvent {
+    name: string;
+    category: 'forward' | 'backward' | 'optimizer' | 'data' | 'communication' | 'other';
+    start: number;
+    duration: number;
+    threadId?: number;
+    gpuId?: number;
+}
+/** Memory profile */
+export interface MemoryProfile {
+    peakMemory: number;
+    allocations: MemoryAllocation[];
+    timeline?: MemoryTimeline;
+}
+/** Memory allocation */
+export interface MemoryAllocation {
+    name: string;
+    size: number;
+    device: 'cpu' | 'gpu';
+}
+/** Memory timeline */
+export interface MemoryTimeline {
+    timestamps: number[];
+    allocated: number[];
+    reserved: number[];
+}
+/** Compute profile */
+export interface ComputeProfile {
+    operatorTimes: OperatorTime[];
+    kernelTimes?: KernelTime[];
+}
+/** Operator time */
+export interface OperatorTime {
+    name: string;
+    selfTime: number;
+    totalTime: number;
+    calls: number;
+}
+/** Kernel time */
+export interface KernelTime {
+    name: string;
+    duration: number;
+    gridSize: number[];
+    blockSize: number[];
+}
+/** IO profile */
+export interface IOProfile {
+    dataLoading: number;
+    checkpointing: number;
+    logging: number;
+}
+/** Bottleneck */
+export interface Bottleneck {
+    type: 'compute' | 'memory' | 'io' | 'communication';
+    severity: 'low' | 'medium' | 'high';
+    description: string;
+    suggestion?: string;
+}
+//# sourceMappingURL=model-training.d.ts.map