Contact UsSOL represents a leap in AI development – a full stack AI compiler and optimizer engineered to unleash the full capacities of AI.
SOL provides a standardized AI hardware-software interface, removing hardware and software bottlenecks while offering optimization and acceleration of neural networks. It enables mathematical accuracy, helps you streamline your AI workloads and enhances AI capabilities for your tasks.
Why SOL?
SOL bridges the gap between advanced hardware and AI frameworks, offering smooth integration with existing AI infrastructure and tools to optimize a wide range of neural networks.
It helps boost performance and reduces memory and compute overhead without requiring hardware or software changes.
How SOL works
SOL integrates smoothly into the AI software and hardware stack, optimizing AI workloads.
Input AI model: Kick-start model development with SOL's one-line integration into Python and your AI frameworks of choice.
SOL then automatically optimizes your AI model in three steps.
Step 1.
High-level transformations. SOL optimizes the AI model using intelligent optimization including:
- Dead code elimination: Cleanses unused code for efficiency
- Deduplication: Merges duplicate operations to save memory
- Mathematical transformations: Reconfigure calculations for optimal performance, keeping the mathematical integrity and accuracy of your model intact
- Device-specific transformations: Tailor operations for specific hardware capabilities when required
Step 2.
Greedy auto-tuning.
SOL's heuristic-based auto-tuning swiftly pinpoints the best optimization paths for your AI model, conducting localized tests that enhance each model layer, without the long wait times typical of global tuning methods.
Step 3.
Code generation.
Generates specific code optimized for target hardware.
The AI model runs efficiently on the chosen target hardware!Which AI frameworks is SOL compatible with?
SOL supports major AI frameworks such as PyTorch, TensorFlow and NumPy, and has the ability to load models trained in one framework (such as TensorFlow) into a different one (such as PyTorch).
What hardware does SOL support?
SOL works with a variety of hardware platforms, offering native, hybrid and offload AI execution modes.
New hardware can be supported by adding hardware plug-ins for SOL.
How can I get started using SOL?
If you’re an AI engineer, you can start by adding SOL as a package in your Python code. If you’re a hardware producer, you can start by substituting SOL for your current compiler.
SOL AI performance gains
NEC customer voices
SOL AI optimization as a service for 6G networks
NEC is a key partner in the European project DESIRE6G, which will design and develop deep programmability and secure distributed intelligence for real-time, end-to-end 6G networks.
Implementing NEC SOL as a service in the DESIRE6G project has led to a 2.5x reduction in memory usage and up to 50x performance improvement for nonstandard recurrent neural networks, demonstrating its efficiency and scalability.
Supercharge your AI
Easy to implement, SOL helps teams develop and deploy AI products faster – retaining model accuracy while reducing energy needed for AI development.
Excellent flexibility
Run AI in your framework and on your hardware of choice
Approval from experts
Developed by compiler experts and validated by customers throughout the AI technology stack
Preserved precision
Enhanced performance while retaining the mathematical equivalence of AI models
Enhanced performance
Automatic optimizations throughout the AI technology stack, with enhanced model training, inference and deployment
Simplified use
Easy integration with Python, custom integrations using SOL SDK, with full-service implementation by NEC
Measuring SOL’s breakthrough performance
Benchmarking SOL against other compilers highlights its efficiency and speed. With an auto-tuning mechanism that outperforms other compilers, SOL helps your AI models run faster, consume less memory, and operate with needed precision. Dive into the metrics that matter and witness the performance gains that SOL consistently delivers.
Figure 6. SOL performance comparison – SOL versus other compilers
SOL benchmarking measurements
| Speed increase | Power efficiency | Memory efficiency | ||
|---|---|---|---|---|
| PyTorch (average) | 1.34x | 1.31x | -4.6% | (0.954) |
| PyTorch (maximum) | 3.23x | 2.91x | -3% | (1.03) |
| Triton (average) | 1.27x | 1.63x | -3.6% | (1.036) |
| Triton (maximum) | 2.77x | 5.26x | -36.9% | (1.369) |
Measured on the L40 and Titan XP (averaged), averaged over all models in our test suite (67 vision models) and averaged over runs with the highest and high precision (float32) on a batch size of 1.
Average: Refers to the average performance difference between SOL and the other compiler. Maximum: Refers to the maximum performance difference between SOL and the other compiler.
See the table above for the numbers.
Statistical comparison to compilers supporting training optimization:
PyTorch [1] and Triton [2]
[1] torch.compile https://pytorch.org/docs/main
[2] https://openai.com/index/triton
| Speed increase | Power efficiency | Memory efficiency | ||
|---|---|---|---|---|
| PyTorch (average) | 5.8x | 2.9x | -4% | (0.96) |
| PyTorch (maximum) | 24x | 10x | +5% | |
| Triton (average) | 4.3x | 2.9x | +18% | (1.18) |
| Triton (maximum) | 14x | 9x | 35% | |
| TensorRT (average) | 1.1x | 1.1x | +1% | (1.01) |
| TensorRT (maximum) | 2.3x | 2.1x | 45% | |
Measured on the L40, averaged over all models in our test suite (67 vision models) and averaged over runs with “highest” and “high” precision (float32) on a batch size of 1.
Average: Refers to the average performance difference between SOL and the other compiler. Maximum: Refers to the maximum performance difference between SOL and the other compiler.
See the table above for the numbers.
Statistical comparison to common compilers:
PyTorch [1], TensorRT [2] and OpenAI’s Triton [3]
[1] torch.compile https://pytorch.org/docs/main
[2] https://developer.nvidia.com/tensorrt
[3] https://openai.com/index/triton
| SOL | TensorFlow | PyTorch | |
|---|---|---|---|
| Install size | <100 MB | 615.3 MB | 766.7 MB |
SOL Deploy streamlines AI integration by converting trained models into stand-alone binaries, eliminating unnecessary code and framework components, thereby reducing overhead and simplifying deployment on target machines.
Comparison against install sizes of AI frameworks:
[1] https://pytorch.org: torch-2.6.0-cp310-cp310-manylinux1_x86_64.whl (766.7 MB)
[2] https://www.tensorflow.org: tensorflow-2.18.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (615.3 MB)
| Triton | SOL | TensorRT | |
|---|---|---|---|
| Average (Median) | 0.75s | 1.6s | 25.5s |
Measured compilation times (including auto-tuning) with an AMD EPYC 7313 for an NVIDIA L40, averaged over all models in our test suite (67 vision models) with "highest" and "high" precision (float32) on a batch size of 1.
In extreme cases, other compilers take up to 50 minutes. SOL consistently stays below 8 seconds for compilation time.
Statistical comparison of SOL to common compilers:
PyTorch compile (with Triton backend) [1] and TensorRT [2]
[1] https://openai.com/index/triton
[2] https://developer.nvidia.com/tensorrt
Enhance AI workloads for different applications
SOL is validated and trusted by NEC customers to enhance AI performance within different technology stacks for a variety of applications in AI research and product development.
