aitbc/apps/zk-circuits/modular_ml_components.circom

pragma circom 2.0.0;

include "node_modules/circomlib/circuits/comparators.circom";

/*
 * Modular ML Circuit Components
 *
 * Reusable components for machine learning circuits
 */

// Basic parameter update component (gradient descent step)
template ParameterUpdate() {
    signal input current_param;
    signal input gradient;
    signal input learning_rate;

    signal output new_param;

    // Simple gradient descent: new_param = current_param - learning_rate * gradient
    new_param <== current_param - learning_rate * gradient;
}

// Vector parameter update component
template VectorParameterUpdate(PARAM_COUNT) {
    signal input current_params[PARAM_COUNT];
    signal input gradients[PARAM_COUNT];
    signal input learning_rate;

    signal output new_params[PARAM_COUNT];

    component updates[PARAM_COUNT];

    for (var i = 0; i < PARAM_COUNT; i++) {
        updates[i] = ParameterUpdate();
        updates[i].current_param <== current_params[i];
        updates[i].gradient <== gradients[i];
        updates[i].learning_rate <== learning_rate;
        new_params[i] <== updates[i].new_param;
    }
}

// Simple loss constraint component
template LossConstraint() {
    signal input predicted_loss;
    signal input actual_loss;
    signal input tolerance;

    // Constrain that |predicted_loss - actual_loss| <= tolerance
    signal diff;
    diff <== predicted_loss - actual_loss;

    // Use absolute value constraint: diff^2 <= tolerance^2
    signal diff_squared;
    diff_squared <== diff * diff;

    signal tolerance_squared;
    tolerance_squared <== tolerance * tolerance;

    // This constraint ensures the loss is within tolerance
    diff_squared * (1 - diff_squared / tolerance_squared) === 0;
}

// Learning rate validation component
template LearningRateValidation() {
    signal input learning_rate;

    // Re-implemented proper validation using efficient comparison circuits
    // Ensures 0 < learning_rate < 1
    component lt1 = LessThan(252);
    component gt0 = GreaterThan(252);
    
    // Ensure learning_rate < 1
    lt1.in[0] <== learning_rate;
    lt1.in[1] <== 1;
    lt1.out === 1;
    
    // Ensure learning_rate > 0
    gt0.in[0] <== learning_rate;
    gt0.in[1] <== 0;
    gt0.out === 1;
}

// Training epoch component
template TrainingEpoch(PARAM_COUNT) {
    signal input epoch_params[PARAM_COUNT];
    signal input epoch_gradients[PARAM_COUNT];
    signal input learning_rate;

    signal output next_epoch_params[PARAM_COUNT];

    component param_update = VectorParameterUpdate(PARAM_COUNT);
    param_update.current_params <== epoch_params;
    param_update.gradients <== epoch_gradients;
    param_update.learning_rate <== learning_rate;
    next_epoch_params <== param_update.new_params;
}

// Main modular training verification using components
template ModularTrainingVerification(PARAM_COUNT, EPOCHS) {
    signal input initial_parameters[PARAM_COUNT];
    signal input learning_rate;

    signal output final_parameters[PARAM_COUNT];
    signal output training_complete;

    // Learning rate validation
    component lr_validator = LearningRateValidation();
    lr_validator.learning_rate <== learning_rate;

    // Training epochs using modular components
    signal current_params[EPOCHS + 1][PARAM_COUNT];

    // Initialize
    for (var i = 0; i < PARAM_COUNT; i++) {
        current_params[0][i] <== initial_parameters[i];
    }

    // Run training epochs
    component epochs[EPOCHS];
    for (var e = 0; e < EPOCHS; e++) {
        epochs[e] = TrainingEpoch(PARAM_COUNT);

        // Input current parameters
        for (var i = 0; i < PARAM_COUNT; i++) {
            epochs[e].epoch_params[i] <== current_params[e][i];
        }

        // Use constant gradients for simplicity (would be computed in real implementation)
        for (var i = 0; i < PARAM_COUNT; i++) {
            epochs[e].epoch_gradients[i] <== 1;  // Constant gradient
        }

        epochs[e].learning_rate <== learning_rate;

        // Store results
        for (var i = 0; i < PARAM_COUNT; i++) {
            current_params[e + 1][i] <== epochs[e].next_epoch_params[i];
        }
    }

    // Output final parameters
    for (var i = 0; i < PARAM_COUNT; i++) {
        final_parameters[i] <== current_params[EPOCHS][i];
    }

    training_complete <== 1;
}

component main = ModularTrainingVerification(4, 3);