LoureiroGate is an innovative differentiable safety layer specifically designed for mission-critical AI applications, primarily built on the PyTorch framework. It addresses the pressing issue of AI hallucinations that can lead to failures in adherence to physical laws and operational constraints. This project ensures that AI models respect limitations that are crucial in various fields, such as:

• Fusion Energy: Preventing models from demanding unsafe magnetic fields that could damage operational equipment.
• Healthcare: Ensuring correct dosage calculations that are age appropriate, thus preventing dangerous prescriptions.
• Robotics: Controlling robotic movements to avoid mechanical failures caused by excessive speeds or forces.

The Solution: Constrained Architecture

LoureiroGate acts as a protective guardrail around existing models, implementing a physical constraint without just clipping the outputs. Instead, it allows models to learn constraints during training and enforces them strictly during execution.

Quick Start Example

To start using LoureiroGate, follow this simple usage example:

import torch
from loureiro_gate import LoureiroGate
from loureiro_gate.constraints import ValueRangeLimit

# 1. Define your existing model
my_robot_controller = torch.nn.Linear(10, 1)

# 2. Set constraints (e.g., Max RPM = 5000)
# 'feature_idx=2' indicates the RPM sensor data
rpm_limit = ValueRangeLimit(feature_idx=2, max_val=5000.0)

# 3. Create alert system for monitoring

def log_violation(safety_level, input_data):
    print(f"CRITICAL: Safety dropped to {safety_level:.2f}! Disengaging AI.")

# 4. Wrap your model with safety constraints
safe_controller = LoureiroGate(
    expert_model=my_robot_controller,
    constraint=rpm_limit,
    fallback='zero',  # Output will be 0 if unsafe
    alert_callback=log_violation
)

# 5. Use the model safely
inputs = torch.randn(1, 10)
output, safety_score = safe_controller(inputs)

Core Architecture: The "Gate"

The architecture employs a differentiable switch mechanism:

$$ \mathbf{y}{safe} = w \cdot f{AI}(\mathbf{x}) + (1 - w) \cdot f_{Fallback}(\mathbf{x}) $$

In this formula, the weight $w$ is derived from the safety score based on the applied constraints. As $w$ approaches 1, the AI maintains full control; conversely, as it approaches 0, the model reverts to the fallback for safety.

Built-in Constraints

LoureiroGate comes with various constraints, including:

• ChargeStarvationLimit: Enforcing limits applicable in relativistic plasma scenarios.
• ValueRangeLimit: Imposing operational boundaries across various parameters such as temperature, pressure, and speed.
• RateOfChangeLimit: Preventing erratic oscillations in outputs.

Future Enhancements

The initial release (v1.0) provides crucial safety measures but is limited to global maximum deviation tracking in batches. Future updates (v1.1) aim to implement more advanced tracking methods for continuous, stateful inference, catering specifically to dedicated robotic controllers.

LoureiroGate represents a significant leap forward in ensuring AI compliance with real-world constraints, making it an essential tool for developers managing complex AI systems.