Machine Learning
Collection
A collection of machine learning models built for practical, efficient, and intelligent applications across different domains. • 1 item • Updated • 1
Zyvra
AI Transaction Risk Intelligence
A lightweight machine learning model for analyzing financial transactions and estimating transaction risk.
Overview
Zyvra is an AI-powered transaction risk intelligence model designed to identify potentially suspicious or high-risk financial transactions.
The model was developed using PyTorch and scikit-learn, then exported to ONNX for efficient and portable inference.
Rather than requiring the original training environment, Zyvra can be deployed through ONNX Runtime, making it suitable for lightweight APIs, backend services, local inference, and other production-oriented machine learning applications.
Zyvra is designed as a transaction-risk intelligence system, not as a definitive fraud verdict.
✦ What Zyvra Does
Zyvra analyzes transaction-level financial signals and produces a risk assessment based on patterns learned during training.
It can be used as a component inside systems such as:
- Financial transaction monitoring
- Fraud-risk screening
- Payment security systems
- Banking infrastructure
- Fintech applications
- Transaction anomaly detection
- Automated risk pipelines
- ML-powered financial APIs
Zyvra is intended to augment existing risk systems, helping applications identify transactions that may warrant additional analysis.
Model Architecture
| Component | Technology |
|---|---|
| Training | PyTorch + scikit-learn |
| Export format | ONNX |
| Inference | ONNX Runtime |
| Domain | Financial transaction risk |
| Input | Structured transaction data |
| Output | Transaction risk assessment |
| Deployment | CPU / ONNX Runtime compatible environments |
The ONNX format provides a portable representation of the trained model that can be consumed independently of the original training framework.
Why ONNX?
Zyvra is distributed in ONNX format to make inference lightweight, portable, and deployment-friendly.
ONNX allows the trained model to be used across different environments without requiring the complete PyTorch training stack.
This makes Zyvra particularly useful for:
- FastAPI services
- Python applications
- Backend ML services
- Edge inference
- Containerized deployments
- CPU-based inference
- Resource-constrained environments
Installation
Install ONNX Runtime:
pip install onnxruntime
For NumPy-based preprocessing and inference:
pip install numpy onnxruntime
Inference
A basic ONNX Runtime session can be created with:
import onnxruntime as ort
session = ort.InferenceSession(
"Zyvra.onnx",
providers=["CPUExecutionProvider"]
)
print(session.get_inputs())
print(session.get_outputs())
You can inspect the model's expected input and output tensors directly through ONNX Runtime.
For example:
input_name = session.get_inputs()[0].name
output_name = session.get_outputs()[0].name
print("Input:", input_name)
print("Output:", output_name)
Then provide a correctly preprocessed NumPy array:
import numpy as np
features = np.array(
[[
# transaction features
]],
dtype=np.float32
)
result = session.run(
[output_name],
{input_name: features}
)
print(result)
Important: Input features must follow the same preprocessing and feature ordering used during training. If preprocessing artifacts such as scalers or encoders are included in this repository, they should be applied before inference.
Example Transaction
A transaction passed into a system using Zyvra could contain information such as:
{
"type": "CASH_OUT",
"amount": 450000.00,
"oldbalanceOrg": 450000.00,
"newbalanceOrig": 0.00,
"oldbalanceDest": 0.00,
"newbalanceDest": 0.00
}
The application layer can transform this transaction into the model's expected numerical representation before passing it to the ONNX model.
Deployment
Zyvra can be integrated into a backend risk-intelligence pipeline:
Transaction
│
▼
Feature Processing
│
▼
Zyvra ONNX Model
│
▼
Risk Assessment
│
├── Low Risk
├── Medium Risk
└── High Risk
A typical production architecture could place Zyvra behind an API such as:
Application
│
▼
Transaction API
│
▼
Preprocessing
│
▼
ONNX Runtime
│
▼
Zyvra
│
▼
Risk Intelligence
Training
Zyvra was developed using a combination of PyTorch and scikit-learn tooling.
The training pipeline involved transforming structured transaction data into numerical features suitable for machine learning, training the model on transaction patterns, and exporting the resulting model to ONNX for deployment.
The final ONNX artifact is intended to separate model training from model inference, allowing applications to perform inference without requiring the complete training environment.
Preprocessing
Correct preprocessing is essential for obtaining meaningful predictions.
Depending on the version of Zyvra and the accompanying artifacts, preprocessing may include:
- Categorical feature encoding
- Numerical feature scaling
- Feature ordering
- Transaction feature transformation
- Model-specific normalization
If preprocessing artifacts are provided alongside the ONNX model, they should be used together with Zyvra.onnx.
Do not manually change feature ordering or preprocessing without retraining or validating the model.
Intended Use
Zyvra is intended for:
- Transaction-risk analysis
- Fraud detection research
- Fintech experimentation
- Financial ML applications
- Risk-scoring pipelines
- Educational machine learning projects
- Backend/API integrations
It can be used as one component within a larger transaction monitoring system.
Out-of-Scope Use
Zyvra should not be used as the sole mechanism for:
- Automatically blocking financial transactions
- Permanently banning users
- Making legal determinations
- Making credit decisions
- Determining criminal activity
- Making decisions without human or system-level review
A machine learning risk score should be treated as one signal among multiple signals.
Limitations & Risks
Zyvra's predictions are dependent on the data and patterns represented during training.
Potential limitations include:
- False positives
- False negatives
- Dataset bias
- Distribution shift
- Previously unseen transaction patterns
- Changes in financial behavior over time
- Differences between training and production data
A transaction identified as high risk is not necessarily fraudulent, and a transaction identified as low risk is not guaranteed to be legitimate.
Production deployments should establish appropriate monitoring, validation, thresholds, and review procedures.
Responsible Use
Zyvra is intended to support risk intelligence, not replace responsible decision-making.
For real-world financial applications, developers should evaluate the model against representative production data and continuously monitor performance after deployment.
Recommended production practices include:
- Monitor false-positive and false-negative rates
- Validate predictions against labeled transactions
- Re-evaluate performance as transaction patterns change
- Maintain appropriate human oversight
- Protect sensitive financial information
- Apply appropriate access controls
- Establish clear decision thresholds
Model Files
The repository may contain the following artifacts:
Zyvra.onnx
scaler.onnx
encoder.json
calib_params.json
Zyvra.onnx
The primary trained Zyvra inference model.
scaler.onnx
Preprocessing component used to transform numerical features where applicable.
encoder.json
Feature/category encoding information used during preprocessing.
calib_params.json
Calibration parameters used by the surrounding inference pipeline where applicable.
Performance
Performance should be evaluated using metrics appropriate for transaction-risk detection, particularly where class imbalance is present.
Recommended evaluation metrics include:
- Precision
- Recall
- F1 Score
- ROC-AUC
- PR-AUC
- False-positive rate
- False-negative rate
Benchmark results should be added here once evaluated on a fixed, representative test set.
Versioning
Zyvra models should be versioned alongside their preprocessing artifacts.
When updating the model, ensure that the following remain synchronized:
Model
+
Preprocessing
+
Feature definitions
+
Calibration
A model and preprocessing artifact from different versions should not be mixed unless compatibility has been verified.
License
This model is released under the MIT License.
See the repository's LICENSE file for the complete license text.
Disclaimer
Zyvra is a machine learning research and engineering project.
It does not provide financial, legal, or professional advice. Predictions generated by the model should not be interpreted as definitive determinations of fraud, legitimacy, or criminal activity.
Users are responsible for validating the model and ensuring that deployments comply with applicable laws, regulations, security requirements, and organizational policies.