How Perforated Works
A PyTorch-native optimization layer that improves model efficiency and accuracy.
ML Stack Integration
Where Perforated Fits
Perforated integrates directly into the training loop between your model and optimizer. It improves model efficiency and accuracy during training while preserving your existing architecture, tooling, and deployment workflow.
- Integrates directly into existing PyTorch workflows
- No architecture rebuilds or deployment changes
- Compatible with standard PyTorch and ONNX export
- No runtime dependencies in production
- Designed for both cloud and edge deployment
Drop into existing training loops
Perforated integrates with minimal code changes. Wrap your model, track validation scores, and continue training as usual.
- 3-5 lines of code for basic integration
- Compatible with existing optimizers and schedulers
- Works with DataParallel and DistributedDataParallel
- Supports mixed precision training (AMP)
import torch
from perforated import perforate_model, PAITracker
# Wrap your existing model
model = YourModel()
model = perforate_model(model)
pai_tracker = PAITracker(model)
# Train normally, track validation scores
for epoch in range(num_epochs):
train_one_epoch(model, train_loader)
val_score = validate(model, val_loader)
model, done = pai_tracker.add_validation_score(val_score, model)Representative integration. Exact implementation depends on your training setup.
Integration Workflow
Four steps from integration to deployment.
1. Integrate
Wrap your existing model with perforate_model(). Typically 3-5 lines of code.
2. Train
Continue your normal training loop. Perforated optimizes structure during backpropagation.
3. Evaluate
Validate against your existing metrics and benchmarks. Compare before/after performance.
4. Deploy
Export optimized model to your target environment. No Perforated runtime required.
What Changes, What Doesn't
Clear boundaries for integration planning
What Changes
- Model initialization (wrapped with perforate_model)
- Training loop (add validation score tracking)
- Computational graph structure (optimized during training)
- Training time (may increase 10-30% during optimization)
- Hyperparameters (may need tuning for optimal results)
What Doesn't Change
- Model architecture definition
- Data pipeline and preprocessing
- Loss functions and evaluation metrics
- Deployment infrastructure
- Inference runtime (no Perforated dependency)
- Model export formats (ONNX, TorchScript, etc.)
- Existing optimization techniques (quantization, pruning)
Open Source vs Enterprise
Choose the right version for your use case
Open Source
Research and evaluation
- Core perforation algorithms
- Basic PyTorch integration
- Community support via GitHub
- MIT license for research use
- No production guarantees
- Limited optimization features
Enterprise
Production deployments
- Production-grade optimizations
- Advanced diagnostic tools
- Compatibility guarantees
- Priority support and SLAs
- Custom integration assistance
- Commercial license included
Product Questions
Technical details about integration, deployment, and evaluation
Where does Perforated sit in the ML stack?
Perforated operates at the training layer, between your model definition and the optimizer. It modifies the model's computational structure during training to improve efficiency and accuracy, then exports a standard PyTorch model for deployment.
What changes in my existing workflow?
Minimal changes: wrap your model with perforate_model(), add validation score tracking, and optionally adjust hyperparameters. Your data pipeline, loss functions, and deployment infrastructure remain unchanged.
What stays the same?
Your model architecture, training data, loss functions, evaluation metrics, deployment pipeline, and inference infrastructure all remain unchanged. Perforated works within your existing stack.
Does Perforated require a runtime dependency?
No. Perforated is used during training only. The optimized model exports as standard PyTorch/ONNX with no runtime dependencies. Your production environment doesn't need Perforated installed.
What's the difference between OSS and proprietary versions?
The open-source version provides core dendritic algorithms for research and evaluation. The proprietary version includes production-grade optimizations, enterprise support, advanced diagnostics, and compatibility guarantees for commercial deployments.
How do I evaluate if Perforated works for my use case?
Run our compatibility check to analyze your model architecture and training setup. We provide a diagnostic report showing expected improvements, integration complexity, and recommended configuration.
Can I use Perforated with quantization or pruning?
Yes. Perforated complements existing optimization techniques. Apply Perforated during training, then use quantization/pruning for deployment. Teams often see better post-compression accuracy when Perforated is applied first.
Ready to Evaluate Perforated?
Run our compatibility check to see if Perforated can improve your models. Most evaluations complete in 1-2 days.