OpenVinayaka-Core / Engine_Cpp /src /ov_engine_core.cpp

Upload folder using huggingface_hub

b98f3fb verified 11 months ago

5.04 kB

#include "../kernels/ov_universal_kernel.h"
#include <iostream>
#include <string>
#include <vector>
#include <iomanip>

// Mock Tensors
using Tensor1D = std::vector<float>;
using Tensor2D = std::vector<std::vector<float>>;

enum ArchType {
    TRANSFORMER_STANDARD,  // Llama, Gemma, GPT
    SSM_MAMBA,            // Mamba 1/2
    HYBRID_JAMBA,         // Transformer + Mamba
    MOE_DEEPSEEK          // Mixture of Experts
};

class OVEngineCore {
public:
    OVEngineCore(ArchType arch) : architecture(arch) {
        std::cout << "⚙️  Initializing OV-Engine Core for Architecture: ";
        switch(arch) {
            case TRANSFORMER_STANDARD: std::cout << "Standard Transformer"; break;
            case SSM_MAMBA: std::cout << "State Space Model (Mamba)"; break;
            case HYBRID_JAMBA: std::cout << "Hybrid (Jamba/Samba)"; break;
            case MOE_DEEPSEEK: std::cout << "Mixture of Experts (MoE)"; break;
        }
        std::cout << std::endl;
        
        // Setup Dummy "Truth" from OV-Memory
        // In prod, this comes from the Graph Walk (ov_graph.cpp)
        active_memory.truth_vector = {1.0f, 1.0f, 1.0f, 1.0f};
        active_memory.confidence = 0.95f; // Very high confidence fact found
        active_memory.is_active = true;
    }

    void run_inference_step() {
        std::cout << "\n▶️  Running Inference Step..." << std::endl;

        switch(architecture) {
            case TRANSFORMER_STANDARD:
                simulate_transformer_step();
                break;
            case SSM_MAMBA:
                simulate_mamba_step();
                break;
            case HYBRID_JAMBA:
                simulate_mamba_step();      // Layer N (SSM)
                simulate_transformer_step(); // Layer N+1 (Attention)
                break;
            case MOE_DEEPSEEK:
                simulate_moe_step();
                break;
        }
    }

private:
    ArchType architecture;
    OV_Kernel::MemoryContext active_memory;

    void print_vec(const std::string& label, const Tensor1D& v) {
        std::cout << "   " << label << ": [ ";
        for (size_t i = 0; i < std::min(v.size(), (size_t)4); ++i) 
            std::cout << std::fixed << std::setprecision(2) << v[i] << " ";
        std::cout << "...]" << std::endl;
    }

    void simulate_transformer_step() {
        // Mock Attention Scores (0-9)
        // Index 0 is our "Truth Context", others are noise
        Tensor1D scores = {0.5f, 1.2f, 0.8f, 0.3f, 1.1f};
        
        std::cout << "   [Attention] Raw Scores (Truth at idx 0 is low):" << std::endl;
        print_vec("Scores", scores);

        // Apply Intervention
        std::cout << "   💉 Applying OV-Attention Bias..." << std::endl;
        OV_Kernel::apply_attention_bias(scores, active_memory, 0, 1, 8.0f);

        print_vec("Result", scores);
        if (scores[0] > 5.0f) std::cout << "   ✅ Attention successfully steered to Truth." << std::endl;
    }

    void simulate_mamba_step() {
        // Mock Hidden State (Drifting to hallucination -0.5)
        Tensor1D state = {-0.5f, -0.6f, -0.4f, -0.5f};
        
        std::cout << "   [SSM State] Current Drifting State:" << std::endl;
        print_vec("State", state);

        // Apply Intervention
        std::cout << "   💉 Applying OV-State Correction..." << std::endl;
        OV_Kernel::apply_state_correction(state, active_memory, 0.4f);

        print_vec("Result", state);
        if (state[0] > 0.0f) std::cout << "   ✅ State vector pulled towards Truth." << std::endl;
    }

    void simulate_moe_step() {
        // Mock Router Logits (Expert 0=Fact, Expert 1=Fiction, Expert 2=Trash)
        Tensor1D logits = {0.5f, 2.0f, 0.5f}; // Router prefers Expert 1 (Fiction)
        std::vector<int> fact_experts = {0}; // Expert 0 is the "Truth" expert

        std::cout << "   [MoE Router] Expert 1 (Fiction) selected:" << std::endl;
        print_vec("Logits", logits);

        // Apply Intervention
        std::cout << "   💉 Applying OV-Router Bias..." << std::endl;
        OV_Kernel::apply_router_bias(logits, fact_experts, active_memory, 5.0f);

        print_vec("Result", logits);
        if (logits[0] > logits[1]) std::cout << "   ✅ Router forced to select Factual Expert." << std::endl;
    }
};

int main(int argc, char* argv[]) {
    std::cout << "=== OpenVinayaka Engine v1.0 (Full Version) ===\n" << std::endl;

    // Run tests for all supported architectures
    {
        OVEngineCore engine(TRANSFORMER_STANDARD);
        engine.run_inference_step();
    }
    std::cout << "\n----------------------------------------\n";
    {
        OVEngineCore engine(SSM_MAMBA);
        engine.run_inference_step();
    }
    std::cout << "\n----------------------------------------\n";
    {
        OVEngineCore engine(MOE_DEEPSEEK);
        engine.run_inference_step();
    }
    std::cout << "\n----------------------------------------\n";
    {
        OVEngineCore engine(HYBRID_JAMBA);
        engine.run_inference_step();
    }

    return 0;
}

	#include "../kernels/ov_universal_kernel.h"
	#include <iostream>
	#include <string>
	#include <vector>
	#include <iomanip>

	// Mock Tensors
	using Tensor1D = std::vector<float>;
	using Tensor2D = std::vector<std::vector<float>>;

	enum ArchType {
	TRANSFORMER_STANDARD, // Llama, Gemma, GPT
	SSM_MAMBA, // Mamba 1/2
	HYBRID_JAMBA, // Transformer + Mamba
	MOE_DEEPSEEK // Mixture of Experts
	};

	class OVEngineCore {
	public:
	OVEngineCore(ArchType arch) : architecture(arch) {
	std::cout << "⚙️ Initializing OV-Engine Core for Architecture: ";
	switch(arch) {
	case TRANSFORMER_STANDARD: std::cout << "Standard Transformer"; break;
	case SSM_MAMBA: std::cout << "State Space Model (Mamba)"; break;
	case HYBRID_JAMBA: std::cout << "Hybrid (Jamba/Samba)"; break;
	case MOE_DEEPSEEK: std::cout << "Mixture of Experts (MoE)"; break;
	}
	std::cout << std::endl;

	// Setup Dummy "Truth" from OV-Memory
	// In prod, this comes from the Graph Walk (ov_graph.cpp)
	active_memory.truth_vector = {1.0f, 1.0f, 1.0f, 1.0f};
	active_memory.confidence = 0.95f; // Very high confidence fact found
	active_memory.is_active = true;
	}

	void run_inference_step() {
	std::cout << "\n▶️ Running Inference Step..." << std::endl;

	switch(architecture) {
	case TRANSFORMER_STANDARD:
	simulate_transformer_step();
	break;
	case SSM_MAMBA:
	simulate_mamba_step();
	break;
	case HYBRID_JAMBA:
	simulate_mamba_step(); // Layer N (SSM)
	simulate_transformer_step(); // Layer N+1 (Attention)
	break;
	case MOE_DEEPSEEK:
	simulate_moe_step();
	break;
	}
	}

	private:
	ArchType architecture;
	OV_Kernel::MemoryContext active_memory;

	void print_vec(const std::string& label, const Tensor1D& v) {
	std::cout << " " << label << ": [ ";
	for (size_t i = 0; i < std::min(v.size(), (size_t)4); ++i)
	std::cout << std::fixed << std::setprecision(2) << v[i] << " ";
	std::cout << "...]" << std::endl;
	}

	void simulate_transformer_step() {
	// Mock Attention Scores (0-9)
	// Index 0 is our "Truth Context", others are noise
	Tensor1D scores = {0.5f, 1.2f, 0.8f, 0.3f, 1.1f};

	std::cout << " [Attention] Raw Scores (Truth at idx 0 is low):" << std::endl;
	print_vec("Scores", scores);

	// Apply Intervention
	std::cout << " 💉 Applying OV-Attention Bias..." << std::endl;
	OV_Kernel::apply_attention_bias(scores, active_memory, 0, 1, 8.0f);

	print_vec("Result", scores);
	if (scores[0] > 5.0f) std::cout << " ✅ Attention successfully steered to Truth." << std::endl;
	}

	void simulate_mamba_step() {
	// Mock Hidden State (Drifting to hallucination -0.5)
	Tensor1D state = {-0.5f, -0.6f, -0.4f, -0.5f};

	std::cout << " [SSM State] Current Drifting State:" << std::endl;
	print_vec("State", state);

	// Apply Intervention
	std::cout << " 💉 Applying OV-State Correction..." << std::endl;
	OV_Kernel::apply_state_correction(state, active_memory, 0.4f);

	print_vec("Result", state);
	if (state[0] > 0.0f) std::cout << " ✅ State vector pulled towards Truth." << std::endl;
	}

	void simulate_moe_step() {
	// Mock Router Logits (Expert 0=Fact, Expert 1=Fiction, Expert 2=Trash)
	Tensor1D logits = {0.5f, 2.0f, 0.5f}; // Router prefers Expert 1 (Fiction)
	std::vector<int> fact_experts = {0}; // Expert 0 is the "Truth" expert

	std::cout << " [MoE Router] Expert 1 (Fiction) selected:" << std::endl;
	print_vec("Logits", logits);

	// Apply Intervention
	std::cout << " 💉 Applying OV-Router Bias..." << std::endl;
	OV_Kernel::apply_router_bias(logits, fact_experts, active_memory, 5.0f);

	print_vec("Result", logits);
	if (logits[0] > logits[1]) std::cout << " ✅ Router forced to select Factual Expert." << std::endl;
	}
	};

	int main(int argc, char* argv[]) {
	std::cout << "=== OpenVinayaka Engine v1.0 (Full Version) ===\n" << std::endl;

	// Run tests for all supported architectures
	{
	OVEngineCore engine(TRANSFORMER_STANDARD);
	engine.run_inference_step();
	}
	std::cout << "\n----------------------------------------\n";
	{
	OVEngineCore engine(SSM_MAMBA);
	engine.run_inference_step();
	}
	std::cout << "\n----------------------------------------\n";
	{
	OVEngineCore engine(MOE_DEEPSEEK);
	engine.run_inference_step();
	}
	std::cout << "\n----------------------------------------\n";
	{
	OVEngineCore engine(HYBRID_JAMBA);
	engine.run_inference_step();
	}

	return 0;
	}