Struct TitansPredictor 

pub struct TitansPredictor { /* private fields */ }

Titans-based message predictor with Neural Long-Term Memory

Unlike standard Transformers with fixed context windows, Titans maintains persistent memory that survives across sequences through surprise-gated test-time training. This enables:

• Unbounded context: Memory consolidates patterns indefinitely
• Anomaly detection: High surprise indicates novel/malicious messages
• Adaptive prediction: Memory updates based on prediction errors

Implementations

impl TitansPredictor

pub fn new(config: TitansConfig) -> Self

pub fn observe(&mut self, message: &[u8])

Add a message to the context for prediction (triggers test-time training)

pub fn predict_next(&mut self) -> (u8, f32)

Predict the next byte

pub fn predict_sequence(&mut self, length: usize, greedy: bool) -> Vec<u8>

Predict multiple bytes autoregressively

pub fn verify_prediction(&mut self, message: &[u8]) -> (bool, f32)

Check if a message matches prediction

pub fn get_surprise(&self) -> f32

Get accumulated surprise (anomaly score) High values indicate unexpected/novel message patterns

pub fn is_anomalous(&self, threshold: f32) -> bool

Check if current message pattern is anomalous

pub fn reset(&mut self)

Reset context window (but preserve long-term memory)

pub fn reset_all(&mut self)

Full reset including long-term memory

pub fn set_temperature(&mut self, temp: f32)

Set temperature for sampling

Trait Implementations

impl Clone for TitansPredictor

fn clone(&self) -> TitansPredictor

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TitansPredictor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TitansPredictor

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TitansPredictor

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.