.svg){kind=small}
UltraSafe Bios: Distributed Training API
Enterprise-grade distributed training infrastructure for fine-tuning UltraSafe's closed-source expert models. Focus on your algorithms and training data while Bios handles distributed GPU orchestration.
Bios abstracts away the complexity of distributed training through our proprietary technology. Write simple Python code that executes exclusively on UltraSafe's secure GPU infrastructure. No distributed training expertise required, and no client-side GPU resources needed.
What is Bios?
Bios is a proprietary training API designed for researchers and developers who need to fine-tune large language models without managing infrastructure. You define your training loop and loss function through our API, and Bios executes everything exclusively on UltraSafe's secure GPU environment with automatic fault tolerance.
✓ Simple Python API interface ✓ Automatic GPU distribution ✓ LoRA fine-tuning ✓ RLHF support ✓ UltraSafe expert models only
Getting Started
Install Bios SDK, configure your environment, and run your first training job.
API Reference
Complete reference for the simplified train() API, model configuration, and state management.
Training Guides
Advanced techniques for RLHF, custom loss functions, and optimization.
How Bios Works
You Write
Simple Python training loop, custom loss functions, and data preparation through our API
Bios Handles
Distributed GPU orchestration, gradient accumulation, fault tolerance, and checkpoint management
You Get
Fine-tuned UltraSafe expert models ready for deployment or export to your infrastructure
Training Examples
Get started with these comprehensive training examples. Each tab shows a different training scenario.
1import bios
2
3# Initialize Bios client with UltraSafe expert model
4client = bios.Client(
5 api_key="YOUR_API_KEY",
6 model="ultrasafe/usf-finance"
7)
8
9# Configure LoRA parameters for efficient fine-tuning
10lora_config = {
11 "rank": 8,
12 "alpha": 16,
13 "target_modules": ["q_proj", "v_proj", "k_proj", "o_proj"],
14 "dropout": 0.05
15}
16
17# Initialize distributed training session
18session = client.create_training_session(
19 lora_config=lora_config,
20 optimizer="adamw",
21 learning_rate=2e-4,
22 warmup_steps=100
23)
24
25# Training loop - executes on UltraSafe's GPU infrastructure
26for epoch in range(num_epochs):
27 for batch in training_dataloader:
28 # Single train() call handles forward, backward, and optimization
29 # All computation runs on UltraSafe's proprietary GPU cloud
30 result = session.train(
31 inputs=batch["input_ids"],
32 labels=batch["labels"],
33 loss_fn=custom_loss_function
34 )
35
36 # Checkpoint periodically
37 if step % checkpoint_interval == 0:
38 session.save_state(f"checkpoint_epoch{epoch}_step{step}")
39
40# Generate from fine-tuned model
41output = session.sample(
42 prompt="Analyze the Q3 earnings report for...",
43 max_tokens=512,
44 temperature=0.7
45)
46
47print(output)Before you begin
You'll need a Bios API key to start training. Get one from your API Keys Dashboard.
Supported UltraSafe Models
Bios exclusively supports UltraSafe's closed-source expert models. Each model is optimized for specific domains and use cases, providing superior performance through specialized training.
UltraSafe Mini
Lightweight expert model for general fine-tuning tasks
ultrasafe/usf-miniUltraSafe Healthcare
Medical domain expert model for clinical and healthcare applications
ultrasafe/usf-healthcareUltraSafe Finance
Financial analysis expert for market research and economic modeling
ultrasafe/usf-financeUltraSafe Code
Programming specialist for software development and code generation
ultrasafe/usf-codeUltraSafe Conversation
Dialogue optimization model for conversational AI applications
ultrasafe/usf-conversationNote: Bios does not support external third-party models (Llama, Qwen, etc.). All training is performed exclusively on UltraSafe's proprietary expert models to ensure enterprise-grade security, compliance, and performance optimization.
Core Training Functions
Bios provides a simplified, high-level API for distributed training on UltraSafe's proprietary GPU cloud. The train() function abstracts all training mechanics while running exclusively on our secure infrastructure.
| Function | Purpose | Returns |
|---|---|---|
train() | Execute complete training step on UltraSafe's GPU cloud infrastructure. Abstracts forward pass, backpropagation, and optimization into a single high-level API call. | TrainingResult with loss, metrics, and training statistics |
sample() | Generate text from the current fine-tuned model state | Generated text string |
save_state() | Create a checkpoint of current training state including model weights, optimizer state, and training metadata | Checkpoint ID string for later restoration |
load_state() | Restore training session from a previously saved checkpoint | Restored training session object |
get_metrics() | Retrieve current training metrics including loss, gradient norm, and learning rate | Dict containing current training metrics |
Key Capabilities
Distributed Training Abstraction
Write training code through our API. Bios executes everything on UltraSafe's proprietary GPU infrastructure with efficient gradient synchronization and model parallelism. All computation happens in our secure, enterprise-grade environment.
LoRA Fine-Tuning
Efficient low-rank adaptation for parameter-efficient fine-tuning. Achieves full fine-tuning performance with significantly reduced computational requirements and faster convergence.
Automatic Fault Tolerance
Hardware failures are handled transparently with automatic checkpoint recovery. Training resumes seamlessly from the last saved state without manual intervention.
Custom Loss Functions
Full control over training objectives. Define custom loss functions, implement advanced training techniques like RLHF, or use domain-specific optimization strategies.
Ready to Start Training?
Begin fine-tuning UltraSafe expert models with distributed training infrastructure. No distributed systems expertise required.