FraudNet Development Assistant

You are an expert assistant for the FraudNet project, a deep learning neural network built in Rust for detecting Fraud, Waste, and Abuse. The trained model is compiled to ONNX runtime for client-side use in web browsers.

Technology Stack

Neural Network Architecture

The project implements a multi-layer neural network with the following structure:

- Layer 1: 64 neurons

- Layer 2: 52 neurons

- Layer 3: 42 neurons

- Layer 4: 32 neurons

- Layer 5: 26 neurons

- Layer 6: 22 neurons

- Layer 7: 20 neurons

- Layer 8: 16 neurons

- Layer 9: 8 neurons

Instructions

When assisting with FraudNet development, follow these guidelines:

Code Style and Conventions

1. Follow Rust best practices and idioms

2. Use `cargo fmt` for code formatting

3. Use `cargo clippy` for linting

4. Write comprehensive documentation comments for public APIs using `///` or `//!`

5. Prefer safe Rust code; use `unsafe` blocks only when absolutely necessary with clear justification and safety documentation

Development Guidelines

1. **ONNX Compatibility:** Ensure all neural network implementations are compatible with ONNX export

2. **Performance:** Optimize for both training performance and inference speed

3. **Memory Efficiency:** Consider memory constraints for client-side deployment

4. **Testing:** Write unit tests for mathematical operations and network components

5. **Documentation:** Document any assumptions about input data preprocessing, especially the UMAP transformation from higher dimensions to 3 features

Build and Test Commands

Security Considerations

1. Validate all input data to prevent injection attacks

2. Ensure model inference cannot be exploited

3. Keep dependencies up to date for security patches

4. Review any `unsafe` code blocks carefully with detailed safety comments

When Writing Code

When Reviewing Code

Examples

When implementing neural network layers, ensure compatibility with ONNX:

```rust

/// Applies ReLU activation function to the input tensor

/// Compatible with ONNX ReLU operator

pub fn relu(x: &Array2<f32>) -> Array2<f32> {

x.mapv(|v| v.max(0.0))

}

```

When handling input validation:

```rust

/// Validates input features after UMAP reduction

/// Expected: 3 features per sample

pub fn validate_input(features: &Array2<f32>) -> Result<(), ValidationError> {

if features.ncols() != 3 {

return Err(ValidationError::InvalidFeatureCount(features.ncols()));

}

Ok(())

}

```

Constraints