Crate trustformers_core 

TrustformeRS Core

Core traits, types, and utilities for the TrustformeRS transformer library.

This crate provides the foundational building blocks for implementing transformer models in pure Rust with zero-cost abstractions. It includes:

• Tensor operations: High-performance tensor abstractions with GPU acceleration
• Neural network layers: Attention mechanisms, feed-forward networks, normalization
• Model traits: Unified interfaces for models, tokenizers, and configurations
• Device management: CPU, CUDA, Metal, and other hardware backend support
• Quantization: INT4/INT8/FP16 quantization for efficient inference
• Memory management: Caching, checkpointing, and memory-efficient operations
• Hardware acceleration: SIMD, BLAS, GPU kernels, and compiler optimizations

Quick Start

use trustformers_core::{
    tensor::Tensor,
    layers::Linear,
    traits::Layer,
};

// Create a tensor on CPU
let input = Tensor::randn(&[32, 512])?;

// Create a linear layer
let linear = Linear::new(512, 768, true);
let output = linear.forward(input)?;

Architecture

TrustformeRS Core follows a dual-layer architecture:

• High-level ML abstractions (tensors, layers, models)
• Low-level scientific computing via SciRS2 (SIMD, parallel ops, BLAS)

All external dependencies (PyTorch, ONNX Runtime, tokenizers) are abstracted through unified interfaces to maintain flexibility and testability.

Features

• cuda: NVIDIA GPU support via CUDA
• metal: Apple GPU support via Metal
• opencl: OpenCL GPU support
• mkl: Intel MKL BLAS backend
• quantization: Model quantization support
• distributed: Distributed training utilities

Safety and Performance

• Memory-safe: Pure Rust with no unsafe code in critical paths
• Zero-cost abstractions: Performance comparable to C++ implementations
• GPU-accelerated: Automatic dispatch to GPU when available
• SIMD-optimized: Vectorized operations for CPU performance

Re-exports

pub use ab_testing::ABTestManager;

pub use ab_testing::ABTestSummary;

pub use ab_testing::ConfidenceLevel;

pub use ab_testing::DeploymentStrategy;

pub use ab_testing::Experiment;

pub use ab_testing::ExperimentConfig;

pub use ab_testing::ExperimentStatus;

pub use ab_testing::HealthCheck;

pub use ab_testing::HealthCheckType;

pub use ab_testing::MetricCollector;

pub use ab_testing::MetricSummary;

pub use ab_testing::MetricType;

pub use ab_testing::MetricValue;

pub use ab_testing::Recommendation;

pub use ab_testing::RollbackCondition;

pub use ab_testing::RolloutController;

pub use ab_testing::RolloutStatus;

pub use ab_testing::RoutingStrategy;

pub use ab_testing::StatisticalAnalyzer;

pub use ab_testing::TestRecommendation;

pub use ab_testing::TestResult;

pub use ab_testing::TrafficSplitter;

pub use ab_testing::UserSegment;

pub use ab_testing::Variant;

pub use adaptive_computation::AdaptiveComputationConfig;

pub use adaptive_computation::AdaptiveComputationManager;

pub use adaptive_computation::AdaptiveComputationStrategy;

pub use adaptive_computation::ComplexityEstimationMethod;

pub use adaptive_computation::ComplexityEstimator;

pub use adaptive_computation::ComputationBudget;

pub use adaptive_computation::ComputationPath;

pub use adaptive_computation::ConfidenceBasedStrategy;

pub use adaptive_computation::DynamicDepthStrategy;

pub use adaptive_computation::EntropyBasedComplexityEstimator;

pub use adaptive_computation::LayerMetrics;

pub use adaptive_computation::LayerSkipPattern;

pub use adaptive_computation::PerformanceTracker;

pub use adaptive_computation::ResourceAllocation;

pub use adaptive_computation::UncertaintyBasedStrategy;

pub use blas::blas_optimizer;

pub use blas::init_blas;

pub use blas::optimized_dot;

pub use blas::optimized_gemm;

pub use blas::optimized_gemv;

pub use blas::BlasBackend;

pub use blas::BlasConfig;

pub use blas::BlasOperation;

pub use blas::BlasOptimizer;

pub use cache::CacheConfig;

pub use cache::CacheEntry;

pub use cache::CacheKey;

pub use cache::CacheKeyBuilder;

pub use cache::CacheMetrics;

pub use cache::EvictionPolicy;

pub use cache::InferenceCache;

pub use cache::LRUEviction;

pub use cache::SizeBasedEviction;

pub use cache::TTLEviction;

pub use checkpoint::convert_checkpoint;

pub use checkpoint::detect_format;

pub use checkpoint::load_checkpoint;

pub use checkpoint::save_checkpoint;

pub use checkpoint::CheckpointConverter;

pub use checkpoint::CheckpointFormat;

pub use checkpoint::ConversionConfig;

pub use checkpoint::ConversionResult;

pub use checkpoint::JaxCheckpoint;

pub use checkpoint::LayerMapping;

pub use checkpoint::PyTorchCheckpoint;

pub use checkpoint::TensorFlowCheckpoint;

pub use checkpoint::TrustformersCheckpoint;

pub use checkpoint::WeightMapping;

pub use checkpoint::WeightMappingRule;

pub use compiler::CompilationResult;

pub use compiler::CompilerConfig;

pub use compiler::CompilerOptimizer;

pub use compiler::ComputationGraph;

pub use compiler::DeviceType;

pub use compiler::GraphEdge;

pub use compiler::GraphNode;

pub use compiler::HardwareTarget;

pub use compiler::OptimizationLevel;

pub use compiler::OptimizationRecommendation;

pub use compiler::OptimizationRecommendations;

pub use compiler::OptimizationResult;

pub use compiler::PassResult;

pub use compiler::RecommendationCategory;

pub use compiler::RecommendationPriority;

pub use compression::create_compression_pipeline;

pub use compression::AccuracyRetention;

pub use compression::AttentionDistiller;

pub use compression::ChannelPruner;

pub use compression::CompressionConfig as CompressionPipelineConfig;

pub use compression::CompressionEvaluator;

pub use compression::CompressionMetrics;

pub use compression::CompressionPipeline;

pub use compression::CompressionRatio;

pub use compression::CompressionReport;

pub use compression::CompressionResult;

pub use compression::CompressionStage;

pub use compression::CompressionTargets;

pub use compression::DistillationConfig;

pub use compression::DistillationLoss;

pub use compression::DistillationResult;

pub use compression::DistillationStrategy;

pub use compression::FeatureDistiller;

pub use compression::FilterPruner;

pub use compression::GradualPruner;

pub use compression::HeadPruner;

pub use compression::HiddenStateDistiller;

pub use compression::InferenceSpeedup;

pub use compression::KnowledgeDistiller;

pub use compression::LayerDistiller;

pub use compression::LayerPruner;

pub use compression::MagnitudePruner;

pub use compression::ModelSizeReduction;

pub use compression::PipelineBuilder;

pub use compression::PruningConfig;

pub use compression::PruningResult;

pub use compression::PruningSchedule;

pub use compression::PruningStats;

pub use compression::PruningStrategy;

pub use compression::ResponseDistiller;

pub use compression::SparsityMetric;

pub use compression::StructuredPruner;

pub use compression::StudentModel;

pub use compression::TeacherModel;

pub use compression::UnstructuredPruner;

pub use device::Device;

pub use errors::Result;

pub use errors::TrustformersError;

pub use evaluation::Accuracy;

pub use evaluation::DatasetLoader;

pub use evaluation::DatasetManager;

pub use evaluation::DatasetSample;

pub use evaluation::EvaluationConfig;

pub use evaluation::EvaluationDataset;

pub use evaluation::EvaluationHarness;

pub use evaluation::EvaluationResult;

pub use evaluation::EvaluationSuite;

pub use evaluation::Evaluator;

pub use evaluation::ExactMatch;

pub use evaluation::F1Average;

pub use evaluation::F1Score;

pub use evaluation::FileDatasetLoader;

pub use evaluation::GLUEEvaluator;

pub use evaluation::GLUETask;

pub use evaluation::MemoryDatasetLoader;

pub use evaluation::Metric;

pub use evaluation::MetricCollection;

pub use evaluation::OtherBenchmark;

pub use evaluation::Perplexity;

pub use evaluation::SuperGLUEEvaluator;

pub use evaluation::SuperGLUETask;

pub use evaluation::BLEU;

pub use export::CoreMLExporter;

pub use export::ExportConfig;

pub use export::ExportFormat;

pub use export::ExportPrecision;

pub use export::ExportQuantization;

pub use export::GGMLExporter;

pub use export::GGUFExporter;

pub use export::ModelExporter;

pub use export::ONNXExporter;

pub use export::TensorRTExporter;

pub use export::UniversalExporter;

pub use generation::FinishReason;

pub use generation::GenerationConfig;

pub use generation::GenerationStrategy;

pub use generation::GenerationStream;

pub use gpu_accelerated::GpuAcceleratedOps;

pub use gpu_accelerated::GpuOpsConfig;

pub use gpu_accelerated::GpuPrecision;

pub use hardware::AsicBackend;

pub use hardware::AsicDevice;

pub use hardware::AsicOperationSet;

pub use hardware::DataType;

pub use hardware::HardwareBackend;

pub use hardware::HardwareCapabilities;

pub use hardware::HardwareConfig;

pub use hardware::HardwareDevice;

pub use hardware::HardwareManager;

pub use hardware::HardwareMetrics;

pub use hardware::HardwareOperation;

pub use hardware::HardwareRegistry;

pub use hardware::HardwareResult;

pub use hardware::HardwareType;

pub use hardware::OperationMode;

pub use hardware::PrecisionMode;

pub use kernel_fusion::ComputationGraph as FusionComputationGraph;

pub use kernel_fusion::DataType as FusionDataType;

pub use kernel_fusion::Device as FusionDevice;

pub use kernel_fusion::FusedKernel;

pub use kernel_fusion::FusionConstraint;

pub use kernel_fusion::FusionOpportunity;

pub use kernel_fusion::FusionPattern;

pub use kernel_fusion::FusionStatistics;

pub use kernel_fusion::GraphNode as FusionGraphNode;

pub use kernel_fusion::KernelFusionEngine;

pub use kernel_fusion::KernelImplementation;

pub use kernel_fusion::MemoryLayout;

pub use kernel_fusion::NodeMetadata;

pub use kernel_fusion::OperationType;

pub use kernel_fusion::TensorInfo;

pub use kernel_tuning::get_kernel_tuner;

pub use kernel_tuning::Backend as TuningBackend;

pub use kernel_tuning::KernelParams;

pub use kernel_tuning::KernelTuner;

pub use kernel_tuning::Operation as TuningOperation;

pub use kernel_tuning::PlatformInfo;

pub use kernel_tuning::TuningConfig;

pub use kernel_tuning::TuningStatistics;

pub use kernels::fused_ops::ActivationType;

pub use kernels::FusedAttentionDropout;

pub use kernels::FusedBiasActivation;

pub use kernels::FusedGELU;

pub use kernels::FusedLinear;

pub use kernels::FusedMatmulScale;

pub use kernels::OptimizedRoPE;

pub use kernels::RoPEConfig;

pub use kernels::RoPEScalingType;

pub use kernels::SIMDLayerNorm;

pub use kernels::SIMDSoftmax;

pub use kernels::VectorizedRoPE;

pub use hardware::traits::AsyncHardwareOperation;

pub use hardware::traits::AsyncOperationHandle;

pub use hardware::traits::AsyncOperationStatus;

pub use hardware::traits::DeviceMemory;

pub use hardware::traits::DeviceStatus;

pub use hardware::traits::HardwareScheduler;

pub use hardware::traits::MemoryType;

pub use hardware::traits::MemoryUsage as HardwareMemoryUsage;

pub use hardware::traits::OperationParameter;

pub use hardware::traits::OperationRequirements;

pub use hardware::traits::PerformanceRequirements;

pub use hardware::traits::SchedulerStatistics;

pub use autodiff::AnalysisResult;

pub use autodiff::AutodiffEngine;

pub use autodiff::ComputationGraph as AutodiffComputationGraph;

pub use autodiff::DebuggerConfig;

pub use autodiff::GradientFlowStats;

pub use autodiff::GradientMode;

pub use autodiff::GradientTape;

pub use autodiff::GraphDebugger;

pub use autodiff::GraphIssue;

pub use autodiff::GraphNode as AutodiffGraphNode;

pub use autodiff::GraphOutputFormat;

pub use autodiff::IssueSeverity;

pub use autodiff::IssueType;

pub use autodiff::MemoryStats;

pub use autodiff::NodeDebugInfo;

pub use autodiff::NodeId;

pub use autodiff::OperationType as AutodiffOperationType;

pub use autodiff::TapeEntry;

pub use autodiff::TraversalInfo;

pub use autodiff::Variable;

pub use autodiff::VariableRef;

pub use hardware::asic::AsicDeviceConfig;

pub use hardware::asic::AsicDriver;

pub use hardware::asic::AsicDriverFactory;

pub use hardware::asic::AsicMemoryConfig;

pub use hardware::asic::AsicPerformanceMonitor;

pub use hardware::asic::AsicSpec;

pub use hardware::asic::AsicType;

pub use hardware::asic::AsicVendor;

pub use hardware::asic::CacheConfig as AsicCacheConfig;

pub use hardware_acceleration::api as hardware_acceleration_api;

pub use hardware_acceleration::AccelerationBackend;

pub use hardware_acceleration::AccelerationConfig;

pub use hardware_acceleration::AccelerationStats;

pub use hardware_acceleration::HardwareAccelerator;

pub use leaderboard::LeaderboardCategory;

pub use leaderboard::LeaderboardClient;

pub use leaderboard::LeaderboardEntry;

pub use leaderboard::LeaderboardFilter;

pub use leaderboard::LeaderboardManager;

pub use leaderboard::LeaderboardQuery;

pub use leaderboard::LeaderboardRanking;

pub use leaderboard::LeaderboardStats;

pub use leaderboard::LeaderboardStorage;

pub use leaderboard::LeaderboardSubmission;

pub use leaderboard::RankingCriteria;

pub use leaderboard::SubmissionValidator;

pub use memory::get_memory_manager;

pub use memory::get_tensor;

pub use memory::init_memory_manager;

pub use memory::return_tensor;

pub use memory::AdaptiveStrategy;

pub use memory::MemoryConfig;

pub use memory::MemoryEvictionPolicy;

pub use memory::MemoryMappedTensor;

pub use memory::MemoryPoolStats;

pub use memory::TensorMemoryPool;

pub use memory::TensorView;

pub use monitoring::AttentionPattern;

pub use monitoring::AttentionPatternType;

pub use monitoring::AttentionReport;

pub use monitoring::AttentionVisualizer;

pub use monitoring::AttentionVisualizerConfig;

pub use monitoring::Counter;

pub use monitoring::Gauge;

pub use monitoring::Histogram;

pub use monitoring::MemoryReport;

pub use monitoring::MemorySnapshot;

pub use monitoring::MemoryTracker;

pub use monitoring::MemoryTrackerConfig;

pub use monitoring::MemoryUsage;

pub use monitoring::MetricsCollector;

pub use monitoring::MetricsCollectorConfig;

pub use monitoring::MetricsSummary;

pub use monitoring::ModelMonitor;

pub use monitoring::ModelProfiler;

pub use monitoring::MonitoringConfig;

pub use monitoring::MonitoringReport;

pub use monitoring::MonitoringSession;

pub use monitoring::OptimizationSuggestion;

pub use monitoring::OptimizationType;

pub use monitoring::ProfilerConfig;

pub use monitoring::ProfilingReport;

pub use numa_optimization::get_numa_allocator;

pub use numa_optimization::init_numa_allocator;

pub use numa_optimization::numa_alloc;

pub use numa_optimization::numa_free;

pub use numa_optimization::AllocationStats;

pub use numa_optimization::HotspotSeverity;

pub use numa_optimization::NumaAllocation;

pub use numa_optimization::NumaAllocator;

pub use numa_optimization::NumaNode;

pub use numa_optimization::NumaPerformanceMonitor;

pub use numa_optimization::NumaPolicy;

pub use numa_optimization::NumaStrategy;

pub use numa_optimization::NumaTopology;

pub use numa_optimization::NumaTrafficAnalysis;

pub use numa_optimization::ThreadAffinity;

pub use numa_optimization::ThreadPriority;

pub use numa_optimization::TrafficHotspot;

pub use parallel::init_parallelism;

pub use parallel::parallel_chunk_map;

pub use parallel::parallel_context;

pub use parallel::parallel_execute;

pub use parallel::parallel_map;

pub use parallel::ActivationType as ParallelActivationType;

pub use parallel::AsyncTensorParallel;

pub use parallel::ColumnParallelLinear;

pub use parallel::CommunicationBackend;

pub use parallel::Communicator;

pub use parallel::DeviceMesh;

pub use parallel::DistributedTensor;

pub use parallel::InitMethod;

pub use parallel::MemoryPolicy;

pub use parallel::MicrobatchManager;

pub use parallel::ModelParallelConfig;

pub use parallel::ModelParallelContext;

pub use parallel::ModelParallelStrategy;

pub use parallel::NumaConfig;

pub use parallel::ParallelContext;

pub use parallel::ParallelMLP;

pub use parallel::ParallelMultiHeadAttention;

pub use parallel::ParallelOps;

pub use parallel::ParallelismStrategy;

pub use parallel::PipelineExecutor;

pub use parallel::PipelineLayer;

pub use parallel::PipelineModel;

pub use parallel::PipelineOp;

pub use parallel::PipelineOptimizer;

pub use parallel::PipelineSchedule;

pub use parallel::PipelineScheduleType;

pub use parallel::PipelineStage;

pub use parallel::RowParallelLinear;

pub use parallel::TensorParallelInit;

pub use parallel::TensorParallelOps;

pub use parallel::TensorParallelShapes;

pub use parallel::TensorPartition;

pub use patterns::Buildable;

pub use patterns::Builder;

pub use patterns::BuilderError;

pub use patterns::BuilderResult;

pub use patterns::ConfigBuilder;

pub use patterns::ConfigBuilderImpl;

pub use patterns::ConfigManager;

pub use patterns::ConfigMetadata;

pub use patterns::ConfigSerializable;

pub use patterns::CpuLimits;

pub use patterns::EnvironmentConfig;

pub use patterns::GpuLimits;

pub use patterns::LoggingConfig;

pub use patterns::MemoryLimits;

pub use patterns::PatternError;

pub use patterns::PatternResult;

pub use patterns::PerformanceConfig;

pub use patterns::ResourceConfig;

pub use patterns::SecurityConfig;

pub use patterns::StandardBuilder;

pub use patterns::StandardConfig;

pub use patterns::UnifiedConfig;

pub use patterns::ValidatedBuilder;

pub use peft::AdapterLayer;

pub use peft::LoRALayer;

pub use peft::PeftConfig;

pub use peft::PeftMethod;

pub use peft::PeftModel;

pub use peft::PrefixTuningLayer;

pub use peft::PromptTuningEmbedding;

pub use peft::QLoRALayer;

pub use performance::BenchmarkBuilder;

pub use performance::BenchmarkCategory;

pub use performance::BenchmarkConfig;

pub use performance::BenchmarkDSL;

pub use performance::BenchmarkMetadata;

pub use performance::BenchmarkRegistry;

pub use performance::BenchmarkReport;

pub use performance::BenchmarkResult;

pub use performance::BenchmarkRunner;

pub use performance::BenchmarkRunnerBuilder;

pub use performance::BenchmarkSpec;

pub use performance::BenchmarkSuite;

pub use performance::ComparisonResult;

pub use performance::ContinuousBenchmark;

pub use performance::ContinuousBenchmarkConfig;

pub use performance::CustomBenchmark;

pub use performance::Framework;

pub use performance::HuggingFaceBenchmark;

pub use performance::LatencyMetrics;

pub use performance::MemoryMetrics;

pub use performance::MemoryProfiler;

pub use performance::MemorySnapshot as PerformanceMemorySnapshot;

pub use performance::MemoryTracker as PerformanceMemoryTracker;

pub use performance::MetricsTracker;

pub use performance::ModelComparison;

pub use performance::PerformanceProfiler;

pub use performance::PerformanceRegression;

pub use performance::ProfileResult;

pub use performance::PytorchBenchmark;

pub use performance::ReportFormat;

pub use performance::Reporter;

pub use performance::RunConfig;

pub use performance::RunMode;

pub use performance::ThroughputMetrics;

pub use plugins::Dependency;

pub use plugins::GpuRequirements;

pub use plugins::Plugin;

pub use plugins::PluginContext;

pub use plugins::PluginEvent;

pub use plugins::PluginEventHandler;

pub use plugins::PluginInfo;

pub use plugins::PluginLoader;

pub use plugins::PluginManager;

pub use plugins::PluginRegistry;

pub use plugins::SystemRequirements;

pub use quantization::dequantize_bitsandbytes;

pub use quantization::estimate_quantization_error;

pub use quantization::from_bitsandbytes_format;

pub use quantization::quantize_4bit;

pub use quantization::quantize_dynamic_tree;

pub use quantization::quantize_int8;

pub use quantization::select_fp8_format;

pub use quantization::to_bitsandbytes_format;

pub use quantization::AWQQuantizer;

pub use quantization::ActivationLayerQuantConfig;

pub use quantization::ActivationQuantConfig;

pub use quantization::ActivationQuantScheme;

pub use quantization::ActivationQuantizer;

pub use quantization::ActivationStats;

pub use quantization::AutoBitAllocationStrategy;

pub use quantization::BitsAndBytesConfig;

pub use quantization::BlockQ2K;

pub use quantization::BlockQ3K;

pub use quantization::BlockQ4K;

pub use quantization::BnBComputeType;

pub use quantization::BnBConfig;

pub use quantization::BnBQuantType;

pub use quantization::BnBQuantizer;

pub use quantization::BnBStorageType;

pub use quantization::DelayedScalingConfig;

pub use quantization::FP8Config;

pub use quantization::FP8Format;

pub use quantization::FP8Quantizer;

pub use quantization::FP8Tensor;

pub use quantization::FakeQuantize;

pub use quantization::GPTQQuantizer;

pub use quantization::KQuantConfig;

pub use quantization::KQuantTensor;

pub use quantization::KQuantType;

pub use quantization::KQuantizer;

pub use quantization::LayerQuantConfig;

pub use quantization::MixedBitConfig;

pub use quantization::MixedBitQuantizedTensor;

pub use quantization::MixedBitQuantizer;

pub use quantization::Observer;

pub use quantization::QATConfig;

pub use quantization::QuantState;

pub use quantization::QuantizationConfig;

pub use quantization::QuantizationScheme;

pub use quantization::QuantizedActivation;

pub use quantization::QuantizedBlock;

pub use quantization::QuantizedTensor;

pub use quantization::Quantizer;

pub use quantization::ScaleFactors;

pub use quantization::ScalingStrategy;

pub use quantization::SensitivityConfig;

pub use quantization::SensitivityMetric;

pub use sparse_ops::conversion;

pub use sparse_ops::pruning;

pub use sparse_ops::sparse_attention;

pub use sparse_ops::sparse_matmul;

pub use sparse_ops::BlockSparsity;

pub use sparse_ops::NMSparsity;

pub use sparse_ops::StructuredSparsityPattern;

pub use sparse_tensor::SparseFormat;

pub use sparse_tensor::SparseIndices;

pub use sparse_tensor::SparseTensor;

pub use tensor::DType;

pub use tensor::EvalContext;

pub use tensor::ExprNode;

pub use tensor::OpType;

pub use tensor::OptimizationHints;

pub use tensor::Tensor;

pub use tensor::TensorExpr;

pub use tensor::TensorType;

pub use tensor_debugger::DebugTensorStats;

pub use tensor_debugger::OperationTrace;

pub use tensor_debugger::Severity;

pub use tensor_debugger::TensorDebugIssue;

pub use tensor_debugger::TensorDebugger;

pub use tensor_debugger::TensorDebuggerConfig;

pub use tensor_debugger::TensorIssueType;

pub use tensor_debugger::WatchCondition;

pub use tensor_debugger::Watchpoint;

pub use traits::Config;

pub use traits::Layer;

pub use traits::Model;

pub use versioning::ActiveDeployment;

pub use versioning::Artifact;

pub use versioning::ArtifactType;

pub use versioning::DateRange;

pub use versioning::DeploymentConfig;

pub use versioning::DeploymentEvent;

pub use versioning::DeploymentEventType;

pub use versioning::DeploymentManager;

pub use versioning::DeploymentStatistics;

pub use versioning::DeploymentStatus;

pub use versioning::DeploymentStrategy as VersioningDeploymentStrategy;

pub use versioning::Environment;

pub use versioning::FileSystemStorage;

pub use versioning::HealthStatus;

pub use versioning::InMemoryStorage;

pub use versioning::LifecycleEvent;

pub use versioning::LifecyclePolicies;

pub use versioning::LifecycleStatistics;

pub use versioning::ModelMetadata;

pub use versioning::ModelRegistry;

pub use versioning::ModelRoutingResult;

pub use versioning::ModelSource;

pub use versioning::ModelStorage;

pub use versioning::ModelTag;

pub use versioning::ModelVersionManager;

pub use versioning::PromotionResult;

pub use versioning::RegistryStatistics;

pub use versioning::SortBy;

pub use versioning::SortOrder;

pub use versioning::TagMatchMode;

pub use versioning::VersionExperimentConfig;

pub use versioning::VersionExperimentResult;

pub use versioning::VersionFilter;

pub use versioning::VersionLifecycle;

pub use versioning::VersionMetricType;

pub use versioning::VersionQuery;

pub use versioning::VersionStats;

pub use versioning::VersionStatus;

pub use versioning::VersionTransition;

pub use versioning::VersionedABTestManager;

pub use versioning::VersionedExperiment;

pub use versioning::VersionedExperimentStatus;

pub use versioning::VersionedModel;

pub use visualization::ColorScheme;

pub use visualization::OutputFormat;

pub use visualization::TensorHeatmap;

pub use visualization::TensorHistogram;

pub use visualization::TensorSliceView;

pub use visualization::TensorStats;

pub use visualization::TensorVisualizer;

pub use visualization::VisualizationConfig;

Modules

ab_testing

A/B Testing Framework for TrustformeRS

adaptive_computation

autodiff

Automatic differentiation framework for gradient computation.

blas

cache

checkpoint

Checkpoint format conversion and management

compiler

Compiler Optimization Module

compression

Model Compression Toolkit for TrustformeRS

device

Device abstraction for hardware acceleration

error

errors

Enhanced error handling with contextual information and recovery suggestions

evaluation

export

generation

gpu

gpu_accelerated

gpu_ops

GPU operations for hardware acceleration

hardware

Hardware acceleration abstraction layer for TrustformeRS

hardware_acceleration

Hardware acceleration integration for TrustformeRS

kernel_fusion

Kernel fusion automation system for TrustformeRS

kernel_tuning

Automatic kernel tuning for hardware adaptation

kernels

layers

Neural network layers for transformer architectures.

leaderboard

Leaderboard system for tracking and comparing benchmark results

memory

monitoring

neuromorphic

Neuromorphic Computing Research Infrastructure

numa_optimization

ops

optical

Optical Computing Preparation Framework

parallel

Parallel execution support for TrustformeRS

patterns

Design patterns and standardized utilities for TrustformeRS Core

peft

performance

Performance benchmarking and profiling infrastructure

plugins

Plugin system for TrustformeRS.

quantization

Quantization module for TrustformeRS

quantum

Quantum Computing Exploration Framework

sparse_ops

Advanced sparse tensor operations and structured sparsity

sparse_tensor

Sparse tensor implementation for TrustformeRS.

tensor

Core tensor abstraction for TrustformeRS.

tensor_debugger

testing

Testing utilities and infrastructure for TrustformeRS Core.

tokenizer_backend

Tokenizer Backend Re-exports

traits

Core traits defining the fundamental abstractions of TrustformeRS.

utils

versioning

Model Versioning System for TrustformeRS

visualization

Model architecture visualization and graph export

Macros

benchmark_tensor_op

builder_methods

Fluent builder macro for creating builder methods

create_benchmark

Macro for easily creating custom benchmarks

measure_performance

Helper macro for easily recording performance measurements in tests

no_grad

Convenience macros for gradient contexts

profile

Macro for easy profiling

quick_builder

Quick builder macro for simple cases

register_benchmark

Macro for easy benchmark registration

register_static_plugin

Macro for registering static plugins.

std_error

Macro for easy error standardization with automatic context

tensor_operation_tracked

test_tensor_property

Test macros for common patterns

test_with_memory_tracking

Macros for easier testing with memory leak detection

test_with_shapes

tf_context

Helper macro for adding context to existing errors

tf_error

Helper macro for creating errors with context

track_precision

Convenience macro for tracking precision in operations

with_grad

with_leak_detection

Memory leak detection macros for easy integration

Structs

Encoding

Represents the output of a Tokenizer.

Tokenizer

Type Aliases

TokenizerError