Hakoniwa AI 箱庭小AI

/*
 * Auto-generated Hakoniwa AI Inference Model (Extreme Bare-Metal C++)
 * [! WARNING: PURE C/C++ MODE !]
 * - No dynamic memory allocation (No std::vector, std::string).
 * - Uses <math.h> only. Weights are stored in 'const' arrays (Flash Memory).
 * - Ultra-low RAM footprint. Perfect for Arduino Uno (ATmega328P).
 */
#include <math.h>

// --- Trained Parameters (Stored in Flash memory to save RAM) ---
const float weights_layer0[6][4] = {{-0.83f, 0.97f, -0.64f, 0.35f}, ...};
const float biases_layer0[4] = {0.04f, 0.16f, -0.01f, -0.04f};

// --- Core Inference Engine ---
// input: Raw normalized/one-hot encoded float array
void predict(const float input[6], float output[2]) {
    float buf_a[4] = {0};
    float buf_b[4] = {0};
    const float* current = input;
    float* next = buf_a;

    // Layer 0 Computation
    for (int j = 0; j < 4; j++) { next[j] = 0.0f; } // Zero clear buffer
    for (int j = 0; j < 4; j++) {
        float total = biases_layer0[j];
        for (int k = 0; k < 6; k++) {
            total += current[k] * weights_layer0[k][j];
        }
        // Activation (ReLU)
        next[j] = (total > 0.0f) ? total : 0.01f * total;
    }
    
    // ... [Buffer switching and Output Layer calculation omitted] ...
}

#if defined(ARDUINO)
void setup() {
    Serial.begin(115200);
    // Manual Data Preparation for {"1", "male", "50.0"}
    // Input 'Pclass' (Category: 1) -> One-hot encoded
    // Input 'Age' (Value: 50.0, Min: 0.0, Max: 100.0) -> Normalized to 0.5f
    float test_input[6] = {1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.5f};
    float result_output[2] = {0};

    unsigned long start_time = micros();
    predict(test_input, result_output);
    unsigned long end_time = micros();

    Serial.println("Predictions:");
    Serial.print("  Survived '0': ");
    Serial.println(result_output[0] * 100);
    Serial.print("Inference Time: ");
    Serial.println(end_time - start_time); // => e.g. "932 microseconds" (on Arduino Uno)"
}
void loop() {}
#endif

// =====================================================================
// Auto-generated Hakoniwa AI Inference Model (Pure Rust)
// Zero external dependencies. Works out of the box with `cargo run`.
// Perfect for WebAssembly (WASM) or high-performance backend microservices.
// =====================================================================
use std::f64::consts::E;

pub struct HakoniwaModel {
    layer_sizes: Vec<usize>,
    // ... [Trained Weights, Biases & Feature Definitions injected here] ...
}

impl HakoniwaModel {
    fn predict_raw(&self, input_data: &[f64]) -> Vec<f64> {
        let mut current = input_data.to_vec();
        for i in 0..self.weights.len() {
            let mut next_layer = vec![0.0; self.layer_sizes[i + 1]];
            for j in 0..self.layer_sizes[i + 1] {
                let mut total = self.biases[i][j];
                for k in 0..self.layer_sizes[i] {
                    total += current[k] * self.weights[i][k][j];
                }
                // Apply activation function (e.g., ReLU)
                if i < self.weights.len() - 1 {
                    next_layer[j] = if total > 0.0 { total } else { 0.01 * total };
                } else {
                    next_layer[j] = total;
                }
            }
            current = next_layer;
        }
        current
    }
    // ... [JSON Formatting Logic omitted] ...
}

// =====================================================================
// Backpropagation (Training Logic)
// Stripped of UI yields and async tasks for educational clarity.
// =====================================================================
double trainEpoch(List<List<double>> inputs, List<List<double>> expectedOutputs) {
  if (inputs.isEmpty) return 0.0;
  double totalLoss = 0.0;
  // Initialize gradients
  List<List<List<double>>> gradW = /*...*/;
  List<List<double>> gradB = /*...*/;

  for (int i = 0; i < inputs.length; i++) {
    List<double> x = inputs[i];
    List<double> y = expectedOutputs[i];
    List<List<double>> activations = _forward(x);
    List<double> o = activations.last;

    // Output layer deltas (e.g. MSE for Sigmoid)
    List<List<double>> deltas = /*...*/;
    for (int j = 0; j < o.length; j++) {
      totalLoss += pow(y[j] - o[j], 2);
      deltas.last[j] = (o[j] - y[j]) * o[j] * (1.0 - o[j]);
    }

    // Hidden layer deltas
    for (int l = weights.length - 2; l >= 0; l--) {
      for (int j = 0; j < layerSizes[l + 1]; j++) {
        double sum = 0.0;
        for (int k = 0; k < layerSizes[l + 2]; k++) {
          sum += deltas[l + 1][k] * weights[l + 1][j][k];
        }
        deltas[l][j] = sum * _derivative(activations[l + 1][j], hiddenActivation);
      }
    }

    // Accumulate gradients
    for (int l = 0; l < weights.length; l++) {
      for (int j = 0; j < layerSizes[l + 1]; j++) {
        gradB[l][j] += deltas[l][j];
        for (int k = 0; k < layerSizes[l]; k++) {
          gradW[l][k][j] += deltas[l][j] * activations[l][k];
        }
      }
    }
  }

  _applyGradients(gradW, gradB, inputs.length);
  return totalLoss / inputs.length;
}