ADAS/HSAP
2
2
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: initial HSAP platform

Browse Source 
Huaxu Sentinel Active Safety Platform with embedded algorithm code,
Docker Compose setup, and vendored dataset scaffolds for clone-and-run.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
Chengfang Lu
2026-05-25 16:59:59 +08:00
commit 7c43b44c57
1619 changed files with 373355 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

169
algorithms/dms_yolo/code/docs/en/platform/account/activity.md Normal file
View File

@@ -0,0 +1,169 @@
---
comments: true
description: Track all account activity and events on Ultralytics Platform with the activity feed, including training, uploads, and system events.
keywords: Ultralytics Platform, activity feed, audit log, notifications, event tracking, activity history
---
# Activity Feed
[Ultralytics Platform](https://platform.ultralytics.com) provides a comprehensive activity feed that tracks all events and actions across your account. Monitor training progress and system events in one centralized location.
<!-- Screenshot: platform-activity-overview.avif -->
## Overview
The Activity Feed serves as your central hub for:
- **Training updates**: Job started, completed, failed, or cancelled
- **Data changes**: Datasets uploaded, modified, or deleted
- **Model events**: Exports, deployments, and inference activity
- **System alerts**: Billing, storage, and account notifications
## Accessing Activity
Navigate to the Activity Feed:
1. Click your profile icon in the top right
2. Select **Activity** from the dropdown
3. Or navigate to **Settings > Activity**
<!-- Screenshot: platform-activity-feed.avif -->
## Activity Types
The Platform tracks the following event types:
| Event Type | Description | Icon |
| ------------- | ------------------------------------- | ----- |
| **created** | New resource created | + |
| **updated** | Resource modified | edit |
| **deleted** | Resource permanently removed | trash |
| **trashed** | Resource moved to trash (recoverable) | trash |
| **restored** | Resource restored from trash | undo |
| **started** | Training or export job started | play |
| **completed** | Job finished successfully | check |
| **failed** | Job encountered an error | error |
| **cancelled** | Job stopped by user | stop |
| **uploaded** | File or dataset uploaded | cloud |
| **exported** | Model exported to format | save |
| **cloned** | Resource duplicated | copy |
## Inbox and Archive
Organize your activity with tabs:
### Inbox
The Inbox shows recent, unread activity:
- New events appear here automatically
- Unread events are highlighted
- Click an event to view details and mark as seen
### Archive
Move events to Archive to keep your Inbox clean:
1. Select events to archive
2. Click **Archive**
3. Access archived events via the Archive tab
!!! tip "Bulk Actions"
Select multiple events using checkboxes to archive or mark as seen in bulk.
## Search and Filtering
Find specific events quickly:
### Search
Use the search bar to find events by:
- Resource name (dataset, model, project)
- Event description
### Filters
Filter events by type:
| Filter | Shows |
| ------------ | ----------------------------------- |
| **All** | All activity types |
| **Training** | Training started, completed, failed |
| **Uploads** | Dataset and model uploads |
| **Exports** | Model export activity |
| **System** | Billing, storage, account events |
### Date Range
Filter by time period:
- **Today**: Events from today
- **This Week**: Events from the past 7 days
- **This Month**: Events from the past 30 days
- **Custom**: Select specific date range
<!-- Screenshot: platform-activity-filters.avif -->
## Event Details
Click an event to view details:
| Field | Description |
| --------------- | --------------------------------- |
| **Timestamp** | When the event occurred |
| **User** | Who triggered the event |
| **Resource** | What was affected (with link) |
| **Description** | Detailed event information |
| **Metadata** | Additional context (job ID, etc.) |
## Mark as Seen
Mark events as seen to track what you've reviewed:
- Click the checkmark icon on individual events
- Use **Mark All Seen** to clear all unread indicators
- Seen events remain accessible but are no longer highlighted
## API Access
Access activity programmatically via the REST API:
```bash
# List activity
curl -H "Authorization: Bearer YOUR_API_KEY" \
https://platform.ultralytics.com/api/activity
# Filter by date range
curl -H "Authorization: Bearer YOUR_API_KEY" \
"https://platform.ultralytics.com/api/activity?startDate=2024-01-01&endDate=2024-01-31"
# Mark events as seen
curl -X POST -H "Authorization: Bearer YOUR_API_KEY" \
https://platform.ultralytics.com/api/activity/mark-seen
# Archive events
curl -X POST -H "Authorization: Bearer YOUR_API_KEY" \
https://platform.ultralytics.com/api/activity/archive
```
See [REST API Reference](../api/index.md#activity-api) for complete documentation.
## FAQ
### How long is activity history retained?
Activity history is retained indefinitely for your account. Archived events are also kept permanently.
### Can I export my activity history?
Yes, use the GDPR data export feature in Settings > Privacy to download all account data including activity history.
### Can I disable activity notifications?
Activity events are always logged for audit purposes. Email notifications can be configured in Settings > Notifications.
### What happens to activity when I delete a resource?
The activity event remains in your history with a note that the resource was deleted. You can still see what happened even after deletion.

259
algorithms/dms_yolo/code/docs/en/platform/account/api-keys.md Normal file
View File

@@ -0,0 +1,259 @@
---
comments: true
description: Create and manage API keys for Ultralytics Platform with scoped permissions for remote training, inference, and programmatic access.
keywords: Ultralytics Platform, API keys, authentication, remote training, security, access control
---
# API Keys
[Ultralytics Platform](https://platform.ultralytics.com) API keys enable secure programmatic access for remote training, inference, and automation. Create scoped keys with specific permissions for different use cases.
<!-- Screenshot: platform-apikeys-list.avif -->
## Create API Key
Create a new API key:
1. Go to **Settings > API Keys**
2. Click **Create Key**
3. Enter a name for the key
4. Select permission scopes
5. Click **Create**
<!-- Screenshot: platform-apikeys-create.avif -->
### Key Name
Give your key a descriptive name:
- `training-server` - For remote training machines
- `ci-pipeline` - For CI/CD integration
- `mobile-app` - For mobile applications
### Permission Scopes
Select scopes to limit key permissions:
<!-- Screenshot: platform-apikeys-scopes.avif -->
| Scope | Permissions |
| ------------ | ---------------------------------- |
| **training** | Start training, stream metrics |
| **models** | Upload, download, delete models |
| **datasets** | Access and modify datasets |
| **read** | Read-only access to all resources |
| **write** | Full write access |
| **admin** | Account management (use carefully) |
!!! tip "Least Privilege"
Create keys with only the permissions needed. Use separate keys for different applications.
### Key Display
After creation, the key is displayed once:
<!-- Screenshot: platform-apikeys-created.avif -->
!!! warning "Copy Your Key"
The full key is only shown once. Copy it immediately and store securely. You cannot retrieve it later.
## Key Format
API keys follow this format:
```
ul_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0
```
- **Prefix**: `ul_` identifies Ultralytics keys
- **Body**: 40 random hexadecimal characters
- **Total**: 43 characters
## Using API Keys
### Environment Variable
Set your key as an environment variable:
=== "Linux/macOS"
```bash
export ULTRALYTICS_API_KEY="ul_your_key_here"
```
=== "Windows"
```powershell
$env:ULTRALYTICS_API_KEY = "ul_your_key_here"
```
### In Code
Use the key in your Python scripts:
```python
import os
# From environment (recommended)
api_key = os.environ.get("ULTRALYTICS_API_KEY")
# Or directly (not recommended for production)
api_key = "ul_your_key_here"
```
### HTTP Headers
Include the key in API requests:
```bash
curl -H "Authorization: Bearer ul_your_key_here" \
https://platform.ultralytics.com/api/...
```
### Remote Training
Enable metric streaming with your key.
!!! warning "Package Version Requirement"
Platform integration requires **ultralytics>=8.4.0**. Lower versions will NOT work with Platform.
```bash
pip install "ultralytics>=8.4.0"
```
```bash
export ULTRALYTICS_API_KEY="ul_your_key_here"
yolo train model=yolo26n.pt data=coco.yaml project=username/project name=exp1
```
## Manage Keys
### View Keys
All keys are listed in Settings > API Keys:
| Column | Description |
| ------------- | -------------------- |
| **Name** | Key identifier |
| **Scopes** | Assigned permissions |
| **Created** | Creation date |
| **Last Used** | Most recent use |
### Revoke Key
Revoke a key that's compromised or no longer needed:
1. Click the key's menu
2. Select **Revoke**
3. Confirm revocation
!!! warning "Immediate Effect"
Revocation is immediate. Any applications using the key will stop working.
### Regenerate Key
If a key is compromised:
1. Create a new key with same scopes
2. Update your applications
3. Revoke the old key
## Security Best Practices
### Do
- Store keys in environment variables
- Use separate keys for different environments
- Revoke unused keys promptly
- Use minimal required scopes
- Rotate keys periodically
### Don't
- Commit keys to version control
- Share keys between applications
- Use admin scope unnecessarily
- Log keys in application output
- Embed keys in client-side code
### Key Rotation
Rotate keys periodically for security:
1. Create new key with same scopes
2. Update applications to use new key
3. Verify applications work correctly
4. Revoke old key
!!! tip "Rotation Schedule"
Consider rotating keys every 90 days for sensitive applications.
## Troubleshooting
### Invalid Key Error
```
Error: Invalid API key
```
Solutions:
1. Verify key is copied correctly
2. Check key hasn't been revoked
3. Ensure key has required scopes
4. Confirm environment variable is set
### Permission Denied
```
Error: Permission denied for this operation
```
Solutions:
1. Check key scopes include required permission
2. Verify you're the resource owner
3. Create new key with correct scopes
### Rate Limited
```
Error: Rate limit exceeded
```
Solutions:
1. Reduce request frequency
2. Implement exponential backoff
3. Contact support for limit increase
## FAQ
### How many keys can I create?
There's no hard limit on API keys. Create as many as needed for different applications and environments.
### Do keys expire?
Keys don't expire automatically. They remain valid until revoked. Consider implementing rotation for security.
### Can I see my key after creation?
No, the full key is shown only once at creation. If lost, create a new key and revoke the old one.
### Are keys region-specific?
Keys work across regions but access data in your account's region only.
### Can I share keys with team members?
Better practice: Have each team member create their own key. This enables:
- Individual activity tracking
- Selective revocation
- Proper access control

302
algorithms/dms_yolo/code/docs/en/platform/account/billing.md Normal file
View File

@@ -0,0 +1,302 @@
---
comments: true
description: Manage credits, payments, and subscriptions on Ultralytics Platform with transparent pricing for cloud training and deployments.
keywords: Ultralytics Platform, billing, credits, pricing, subscription, payments, training costs
---
# Billing
[Ultralytics Platform](https://platform.ultralytics.com) uses a credit-based billing system for cloud training and dedicated endpoints. Add credits, track usage, and manage your subscription.
<!-- Screenshot: platform-billing-overview.avif -->
## Plans
Choose the plan that fits your needs:
<!-- Screenshot: platform-billing-plans.avif -->
| Feature | Free | Pro ($29/mo) | Enterprise |
| ----------------------- | ---------------------- | ------------ | ---------- |
| **Signup Credit** | $5 ($25 company email) | $25/month | Custom |
| **Credit Expiry** | 30 days | 30 days | Custom |
| **Storage** | 100 GB | 500 GB | Unlimited |
| **Private Projects** | Unlimited | Unlimited | Unlimited |
| **Deployments** | 3 (cold-start) | 3 | Unlimited |
| **Teams** | - | Yes | Yes |
| **Dedicated Endpoints** | - | Yes | Yes |
| **Priority Training** | - | Yes | Yes |
| **SSO/Audit Logs** | - | - | Yes |
| **License** | AGPL | AGPL | Enterprise |
### Free Plan
Get started at no cost:
- $5 signup credit ($25 for company/work emails)
- Credits expire in 30 days
- 100 GB storage
- Unlimited private projects
- 3 deployments (cold-start, scale to zero when idle)
- Community support
!!! tip "Company Email Bonus"
Sign up with a company email address (not gmail.com, outlook.com, etc.) to receive $25 in signup credits instead of $5.
### Pro Plan
For serious users and small teams ($29/month):
- $25 monthly credit (recurring, expires in 30 days)
- 500 GB storage
- Unlimited private projects
- 3 deployments with dedicated endpoints
- Priority training queue
- Email support
### Enterprise
For organizations with advanced needs:
- Custom credit allocation and expiry
- Unlimited storage
- Unlimited deployments
- SSO/SAML integration
- Audit logging
- Dedicated support
- Enterprise license (non-AGPL)
Contact [sales@ultralytics.com](mailto:sales@ultralytics.com) for Enterprise pricing.
## Credits
Credits are the currency for Platform compute services. All amounts are stored internally in **micro-USD** (1 dollar = 1,000,000 micro-USD) for precise accounting.
### Credit Balance
View your balance in Settings > Billing:
<!-- Screenshot: platform-billing-credits.avif -->
| Balance Type | Description |
| ------------------ | --------------------------------------------- |
| **Cash Balance** | Purchased credits (from Stripe top-ups) |
| **Credit Balance** | Promotional credits (signup, monthly rewards) |
| **Reserved** | Held for active training jobs |
| **Available** | Total balance minus reserved amount |
Your actual available balance for starting new training is calculated as:
```
Available = (Cash Balance + Credit Balance) - Reserved Amount
```
### Credit Uses
Credits are consumed by:
| Service | Rate |
| ----------------------- | -------------------- |
| **Cloud Training** | GPU rate × hours |
| **Dedicated Endpoints** | Compute rate × hours |
| **Model Export** | Fixed per export |
### Credit Expiration
Credits have expiration dates:
- **Signup credits**: 30 days from account creation
- **Monthly credits**: 30 days from issue date
- **Purchased credits**: Never expire
!!! tip "FIFO Credit Consumption"
Credits are consumed in FIFO (First In, First Out) order - oldest expiring credits are used first. This ensures promotional credits are used before they expire, while your purchased credits remain available longer.
## Add Credits
Top up your balance:
1. Go to **Settings > Billing**
2. Click **Add Credits**
3. Select amount ($5 - $1000)
4. Complete payment
<!-- Screenshot: platform-billing-topup.avif -->
### Payment Methods
- Credit/debit cards
- Major payment providers
### Purchase Options
| Amount | Bonus | Total |
| ------ | ----- | ----- |
| $5 | - | $5 |
| $25 | - | $25 |
| $50 | - | $50 |
| $100 | - | $100 |
| $500 | - | $500 |
| $1000 | - | $1000 |
## Training Cost Flow
Cloud training uses a **hold/settle/release** system to ensure you're never charged more than the estimated cost shown before training starts.
```mermaid
flowchart LR
A[Start Training] --> B[Create Hold]
B --> C{Training Complete?}
C -->|Yes| D[Settle: Charge Actual Cost]
C -->|Canceled| E[Release: Full Refund]
D --> F[Refund Excess]
```
### How It Works
1. **Estimate**: Platform calculates estimated cost based on model size, dataset size, epochs, and GPU
2. **Hold**: Estimated cost (plus 20% safety margin) is reserved from your balance
3. **Train**: Reserved amount shows as "Reserved" in your balance during training
4. **Settle**: After completion, you're charged only for actual GPU time used
5. **Refund**: Any excess is returned proportionally (credits first, then cash)
!!! success "Consumer Protection"
You're **never charged more than the estimate** shown before training. If training completes early or is canceled, you only pay for actual compute time used.
## Training Costs
Cloud training costs depend on GPU selection:
| Tier | GPU | VRAM | Rate/Hour | Typical Job (1h) |
| ---------- | ------------ | ------ | --------- | ---------------- |
| Budget | RTX A2000 | 6 GB | $0.12 | $0.12 |
| Budget | RTX 3080 | 10 GB | $0.25 | $0.25 |
| Budget | RTX 3080 Ti | 12 GB | $0.30 | $0.30 |
| Budget | A30 | 24 GB | $0.44 | $0.44 |
| Mid | L4 | 24 GB | $0.54 | $0.54 |
| Mid | RTX 4090 | 24 GB | $0.60 | $0.60 |
| Mid | A6000 | 48 GB | $0.90 | $0.90 |
| Mid | L40S | 48 GB | $1.72 | $1.72 |
| Pro | A100 40GB | 40 GB | $2.78 | $2.78 |
| Pro | A100 80GB | 80 GB | $3.44 | $3.44 |
| Pro | RTX PRO 6000 | 48 GB | $3.68 | $3.68 |
| Pro | H100 | 80 GB | $5.38 | $5.38 |
| Enterprise | H200 | 141 GB | $5.38 | $5.38 |
| Enterprise | B200 | 192 GB | $10.38 | $10.38 |
See [Cloud Training](../train/cloud-training.md) for complete GPU options and pricing.
### Cost Calculation
```
Total Cost = GPU Rate × Training Time (hours)
```
Example: Training for 2.5 hours on RTX 4090
```
$1.18 × 2.5 = $2.95
```
### Billing Timing
- **Epochs mode**: Charged after each epoch
- **Timed mode**: Charged at completion
- **Canceled**: Charged for completed time only
## Upgrade to Pro
Upgrade for more features and monthly credits:
1. Go to **Settings > Billing**
2. Click **Upgrade to Pro**
3. Complete checkout
<!-- Screenshot: platform-billing-upgrade.avif -->
### Pro Benefits
After upgrading:
- $25 credit added immediately
- $25 credit added each month (recurring)
- Storage increased to 500 GB
- Unlimited private projects
- 3 dedicated deployments
- Priority training queue
### Cancel Pro
Cancel anytime from the billing portal:
1. Click **Manage Subscription**
2. Select **Cancel**
3. Confirm cancellation
!!! note "Cancellation Timing"
Pro features remain active until the end of your billing period. Monthly credits stop at cancellation.
## Payment History
View all transactions:
<!-- Screenshot: platform-billing-history.avif -->
| Column | Description |
| --------------- | ------------------------------- |
| **Date** | Transaction date |
| **Description** | Credit purchase, training, etc. |
| **Amount** | Transaction value |
| **Balance** | Resulting balance |
### Download Invoice
1. Click transaction in history
2. Select **Download Invoice**
3. PDF invoice downloads
## Billing Portal
Access the billing portal for:
- Update payment method
- Download invoices
- Manage subscription
- View billing history
## FAQ
### What happens when I run out of credits?
- **Active training**: Pauses at epoch end
- **Deployments**: Continue running
- **New training**: Cannot start
Add credits to continue training.
### Are unused credits refundable?
- **Purchased credits**: No refunds
- **Signup/monthly credits**: No refunds (use it or lose it)
### Can I transfer credits?
Credits are not transferable between accounts.
### How do I get an invoice?
1. Go to **Settings > Billing**
2. Click **Billing Portal**
3. Download invoices
### What if training fails?
You're only charged for completed compute time. Failed jobs don't charge for unused time.
### Is there a free trial?
The Free plan includes $5 signup credit - essentially a free trial. No credit card required to start.

103
algorithms/dms_yolo/code/docs/en/platform/account/index.md Normal file
View File

@@ -0,0 +1,103 @@
---
comments: true
description: Manage your Ultralytics Platform account including API keys, billing, and user settings with security and GDPR compliance.
keywords: Ultralytics Platform, account, settings, API keys, billing, security, GDPR
---
# Account Management
[Ultralytics Platform](https://platform.ultralytics.com) provides comprehensive account management for API keys, billing, and user settings. Manage your account securely with GDPR-compliant data handling.
## Overview
The Account section helps you:
- **Create** and manage API keys for programmatic access
- **Track** credit balance and billing
- **Configure** profile and preferences
- **Export** your data for GDPR compliance
<!-- Screenshot: platform-account-overview.avif -->
## Account Features
| Feature | Description |
| ------------ | ---------------------------------------------- |
| **API Keys** | Secure keys for remote training and API access |
| **Billing** | Credits, payments, and usage tracking |
| **Activity** | Track events and account actions |
| **Trash** | Recover deleted items within 30 days |
| **Settings** | Profile, region, and preferences |
| **GDPR** | Data export and account deletion |
## Security
Ultralytics Platform implements multiple security measures:
### Authentication
- **OAuth2**: Sign in with Google, Apple, or GitHub
- **Email**: Traditional email/password authentication
- **Session management**: Secure, expiring sessions
### Data Protection
- **Encryption**: All data encrypted at rest and in transit
- **API Keys**: Securely encrypted storage
- **Region isolation**: Data stays in your selected region
### Access Control
- **Per-key scopes**: Limit API key permissions
- **Session timeout**: Automatic logout after inactivity
- **Audit logging**: Track all account activity
## Quick Links
- [**API Keys**](api-keys.md): Create and manage API keys
- [**Billing**](billing.md): Credits and payment management
- [**Activity**](activity.md): Track account events and notifications
- [**Trash**](trash.md): Recover deleted projects, datasets, and models
- [**Settings**](settings.md): Profile and preferences
## FAQ
### How do I change my email address?
Email changes are managed through your OAuth provider (Google, Apple, GitHub) or:
1. Go to Settings
2. Click **Edit Profile**
3. Update email address
4. Verify new email
### How do I delete my account?
Account deletion is available in Settings:
1. Go to Settings > Privacy
2. Click **Delete Account**
3. Confirm deletion
!!! warning "Permanent Action"
Account deletion is permanent. All data, models, and deployments are removed. Export your data first if needed.
### Is my data secure?
Yes, Ultralytics Platform implements:
- Secure encrypted connections
- Encryption at rest
- Regional data isolation
- Regular security audits
### Can I change my data region?
No, data region is selected during signup and cannot be changed. To use a different region:
1. Export your data
2. Create a new account in desired region
3. Re-upload your data
This ensures data residency compliance.

241
algorithms/dms_yolo/code/docs/en/platform/account/settings.md Normal file
View File

@@ -0,0 +1,241 @@
---
comments: true
description: Configure your Ultralytics Platform profile, preferences, and data settings with GDPR-compliant data export and deletion options.
keywords: Ultralytics Platform, settings, profile, preferences, GDPR, data export, privacy
---
# Settings
[Ultralytics Platform](https://platform.ultralytics.com) settings allow you to configure your profile, preferences, and manage your data with GDPR-compliant export and deletion options.
## Profile Settings
Update your profile information:
<!-- Screenshot: platform-settings-profile.avif -->
| Field | Description |
| ----------------- | -------------------------------- |
| **Display Name** | Your public name |
| **Username** | Unique identifier (used in URLs) |
| **Bio** | Short description |
| **Company** | Organization name |
| **Use Case** | Primary application |
| **Profile Image** | Avatar displayed across Platform |
### Edit Profile
1. Go to **Settings > Profile**
2. Update fields
3. Click **Save**
### Username Rules
- 3-30 characters
- Lowercase letters, numbers, hyphens
- Cannot start/end with hyphen
- Must be unique
!!! warning "Username Changes"
Changing username updates all your public URLs. Old URLs will stop working.
## Social Links
Add links to your profiles:
<!-- Screenshot: platform-settings-social.avif -->
| Platform | URL Format |
| ------------ | ------------------------ |
| **GitHub** | github.com/username |
| **Twitter** | twitter.com/username |
| **LinkedIn** | linkedin.com/in/username |
| **Website** | your-website.com |
Social links appear on your public profile page.
## Data Region
View your data region:
<!-- Screenshot: platform-settings-region.avif -->
| Region | Location | Best For |
| ------ | -------------------- | --------------------------------------- |
| **US** | Iowa, USA | Americas users, fastest for Americas |
| **EU** | Belgium, Europe | European users, GDPR compliance |
| **AP** | Taiwan, Asia-Pacific | Asia-Pacific users, lowest APAC latency |
!!! note "Region is Permanent"
Data region is selected during signup and cannot be changed. All your data stays in this region.
## Storage Usage
Monitor your storage consumption:
<!-- Screenshot: platform-settings-storage.avif -->
| Type | Description |
| ------------ | ----------------------- |
| **Datasets** | Image and label storage |
| **Models** | Checkpoint storage |
| **Exports** | Exported model formats |
### Storage Limits
| Plan | Limit |
| ---------- | --------- |
| Free | 100 GB |
| Pro | 500 GB |
| Enterprise | Unlimited |
### Reduce Storage
To free up storage:
1. Delete unused datasets
2. Remove old model checkpoints
3. Delete exported formats
4. Empty trash (Settings > Trash)
## Trash
Deleted items go to Trash for 30 days:
1. Go to **Settings > Trash**
2. View deleted projects, datasets, models
3. **Restore** to recover, or **Delete** permanently
### Auto-Cleanup
Items in Trash are permanently deleted after 30 days. This cannot be undone.
## GDPR Compliance
Ultralytics Platform supports GDPR rights:
### Data Export
Download all your data:
<!-- Screenshot: platform-settings-gdpr.avif -->
1. Go to **Settings > Privacy**
2. Click **Export Data**
3. Receive download link via email
Export includes:
- Profile information
- Dataset metadata
- Model metadata
- Training history
- API key metadata (not secrets)
### Account Deletion
Permanently delete your account:
1. Go to **Settings > Privacy**
2. Click **Delete Account**
3. Type confirmation phrase
4. Confirm deletion
!!! warning "Irreversible Action"
Account deletion is permanent. All data is removed within 30 days per GDPR requirements.
### What's Deleted
- Profile and settings
- All datasets and images
- All models and checkpoints
- All deployments
- API keys
- Billing history
### What's Retained
- Anonymized analytics
- Server logs (90 days)
- Legal compliance records
## Notifications
Configure notification preferences:
| Type | Options |
| --------------------- | ---------------- |
| **Training Complete** | Email, none |
| **Deployment Status** | Email, none |
| **Billing Alerts** | Email (required) |
| **Product Updates** | Email, none |
## Theme
Select your preferred theme:
| Theme | Description |
| ---------- | ---------------- |
| **Light** | Light background |
| **Dark** | Dark background |
| **System** | Match OS setting |
## Sessions
Manage active sessions:
1. Go to **Settings > Security**
2. View active sessions
3. **Revoke** suspicious sessions
Session information:
- Device type
- Browser
- Location (approximate)
- Last active
## FAQ
### How do I change my email?
Email is managed through your OAuth provider:
1. Update email in Google/Apple/GitHub
2. Sign out and sign in again
3. Platform updates automatically
### Can I have multiple accounts?
You can create accounts in different regions, but:
- Each needs a unique email
- Data doesn't transfer between accounts
- Billing is separate
### How do I change my password?
Passwords are managed by your OAuth provider:
- **Google**: accounts.google.com
- **Apple**: appleid.apple.com
- **GitHub**: github.com/settings/security
### Is two-factor authentication available?
2FA is handled by your OAuth provider. Enable 2FA in:
- Google Account settings
- Apple ID settings
- GitHub Security settings
### How long until deleted data is removed?
| Type | Timeline |
| -------------------- | ------------- |
| **Trash items** | 30 days |
| **Account deletion** | Up to 30 days |
| **Backups** | 90 days |

168
algorithms/dms_yolo/code/docs/en/platform/account/trash.md Normal file
View File

@@ -0,0 +1,168 @@
---
comments: true
description: Learn how to recover deleted projects, datasets, and models from Trash on Ultralytics Platform with the 30-day soft delete policy.
keywords: Ultralytics Platform, trash, restore, soft delete, recover, deleted items, data recovery
---
# Trash and Restore
[Ultralytics Platform](https://platform.ultralytics.com) implements a 30-day soft delete policy, allowing you to recover accidentally deleted projects, datasets, and models. Deleted items are moved to Trash where they can be restored before permanent deletion.
<!-- Screenshot: platform-trash-overview.avif -->
## Soft Delete Policy
When you delete a resource on the Platform:
1. **Immediate**: Item moves to Trash (not permanently deleted)
2. **30 Days**: Item remains recoverable in Trash
3. **After 30 Days**: Item is permanently deleted automatically
!!! success "Recovery Window"
You have 30 days to restore any deleted item. After this period, the item and all associated data are permanently removed and cannot be recovered.
## Accessing Trash
Navigate to your Trash:
1. Go to **Settings** (gear icon)
2. Click **Trash** in the sidebar
3. Or navigate directly to Settings > Trash
<!-- Screenshot: platform-trash-list.avif -->
## Trash Contents
The Trash shows all soft-deleted resources:
| Resource Type | What's Included When Deleted |
| ------------- | ------------------------------------------ |
| **Projects** | Project + all models inside |
| **Datasets** | Dataset + all images and annotations |
| **Models** | Model weights + training history + exports |
### Viewing Trash Items
Each item in Trash displays:
- **Name**: Original resource name
- **Type**: Project, Dataset, or Model
- **Deleted**: Date and time of deletion
- **Expires**: When permanent deletion occurs
- **Size**: Storage used by the item
## Restoring Items
Recover a deleted item:
1. Navigate to **Settings > Trash**
2. Find the item you want to restore
3. Click the **Restore** button
4. Confirm restoration
<!-- Screenshot: platform-trash-restore.avif -->
The item returns to its original location with all data intact.
### Restore Behavior
| Resource | Restore Behavior |
| -------- | ---------------------------------------------------------------------------- |
| Project | Restores project and all contained models |
| Dataset | Restores dataset with all images and annotations |
| Model | Restores model to original project (or orphaned if project was also deleted) |
!!! note "Parent Dependency"
If you deleted both a project and its models, restore the project first. This automatically restores all models that were inside it.
## Permanent Deletion
### Automatic Deletion
Items in Trash are automatically and permanently deleted after 30 days. This process:
- Runs daily
- Removes items older than 30 days
- Frees up storage space
- Cannot be reversed
### Empty Trash
Permanently delete all items immediately:
1. Navigate to **Settings > Trash**
2. Click **Empty Trash**
3. Confirm the action
!!! warning "Irreversible Action"
Emptying Trash permanently deletes all items immediately. This action cannot be undone and all data will be lost.
### Delete Single Item Permanently
To permanently delete one item without waiting:
1. Find the item in Trash
2. Click the **Delete Permanently** button
3. Confirm deletion
## Storage and Trash
Items in Trash still count toward your storage quota:
| Scenario | Storage Impact |
| -------------------- | ------------------------------ |
| Delete item | Storage remains allocated |
| Restore item | No change (was still counting) |
| Permanent deletion | Storage freed |
| 30-day auto-deletion | Storage freed automatically |
!!! tip "Free Up Storage"
If you're running low on storage, empty Trash or permanently delete specific items to immediately reclaim space.
## API Access
Manage Trash programmatically via the REST API:
```bash
# List items in Trash
curl -H "Authorization: Bearer YOUR_API_KEY" \
https://platform.ultralytics.com/api/trash
# Restore an item
curl -X POST -H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"itemId": "item_abc123", "type": "dataset"}' \
https://platform.ultralytics.com/api/trash
# Empty Trash (permanently delete all)
curl -X POST -H "Authorization: Bearer YOUR_API_KEY" \
https://platform.ultralytics.com/api/trash/empty
```
See [REST API Reference](../api/index.md#trash-api) for complete documentation.
## FAQ
### Can I restore an item after 30 days?
No. After 30 days, items are permanently deleted and cannot be recovered. Make sure to restore important items before the expiration date shown in Trash.
### What happens when I delete a project with models?
Both the project and all models inside it move to Trash together. Restoring the project restores all its models. You can also restore individual models separately.
### Do items in Trash count toward storage?
Yes, items in Trash continue to use storage quota. To free up space, permanently delete items or empty Trash.
### Can I recover a model if its project was permanently deleted?
No. If a project is permanently deleted, all models that were inside it are also permanently deleted. Always restore items before the 30-day window expires.
### How do I know when an item will be permanently deleted?
Each item in Trash shows an "Expires" date indicating when automatic permanent deletion will occur.

879
algorithms/dms_yolo/code/docs/en/platform/api/index.md Normal file
View File

@@ -0,0 +1,879 @@
---
comments: true
description: Complete REST API reference for Ultralytics Platform including authentication, endpoints, and examples for datasets, models, and deployments.
keywords: Ultralytics Platform, REST API, API reference, authentication, endpoints, YOLO, programmatic access
---
# REST API Reference
[Ultralytics Platform](https://platform.ultralytics.com) provides a comprehensive REST API for programmatic access to datasets, models, training, and deployments.
<!-- Screenshot: platform-api-overview.avif -->
!!! tip "Quick Start"
```bash
# List your datasets
curl -H "Authorization: Bearer YOUR_API_KEY" \
https://platform.ultralytics.com/api/datasets
# Run inference on a model
curl -X POST \
-H "Authorization: Bearer YOUR_API_KEY" \
-F "file=@image.jpg" \
https://platform.ultralytics.com/api/models/MODEL_ID/predict
```
## Authentication
All API requests require authentication via API key.
### Get API Key
1. Go to **Settings > API Keys**
2. Click **Create Key**
3. Copy the generated key
See [API Keys](../account/api-keys.md) for detailed instructions.
### Authorization Header
Include your API key in all requests:
```bash
Authorization: Bearer ul_your_api_key_here
```
### Example
```bash
curl -H "Authorization: Bearer ul_abc123..." \
https://platform.ultralytics.com/api/datasets
```
## Base URL
All API endpoints use:
```
https://platform.ultralytics.com/api
```
## Rate Limits
| Plan | Requests/Minute | Requests/Day |
| ---------- | --------------- | ------------ |
| Free | 60 | 1,000 |
| Pro | 300 | 50,000 |
| Enterprise | Custom | Custom |
Rate limit headers are included in responses:
```
X-RateLimit-Limit: 60
X-RateLimit-Remaining: 55
X-RateLimit-Reset: 1640000000
```
## Response Format
All responses are JSON:
```json
{
"success": true,
"data": { ... },
"meta": {
"page": 1,
"limit": 20,
"total": 100
}
}
```
### Error Responses
```json
{
"success": false,
"error": {
"code": "VALIDATION_ERROR",
"message": "Invalid dataset ID",
"details": { ... }
}
}
```
## Datasets API
### List Datasets
```
GET /api/datasets
```
**Query Parameters:**
| Parameter | Type | Description |
| --------- | ------ | ---------------------------- |
| `page` | int | Page number (default: 1) |
| `limit` | int | Items per page (default: 20) |
| `task` | string | Filter by task type |
**Response:**
```json
{
"success": true,
"data": [
{
"id": "dataset_abc123",
"name": "my-dataset",
"slug": "my-dataset",
"task": "detect",
"imageCount": 1000,
"classCount": 10,
"visibility": "private",
"createdAt": "2024-01-15T10:00:00Z"
}
]
}
```
### Get Dataset
```
GET /api/datasets/{datasetId}
```
### Create Dataset
```
POST /api/datasets
```
**Body:**
```json
{
"name": "my-dataset",
"task": "detect",
"description": "A custom detection dataset"
}
```
### Delete Dataset
```
DELETE /api/datasets/{datasetId}
```
### Export Dataset
```
POST /api/datasets/{datasetId}/export
```
Returns NDJSON format download URL.
### Get Models Trained on Dataset
```
GET /api/datasets/{datasetId}/models
```
Returns list of models that were trained using this dataset, showing the relationship between datasets and the models they produced.
**Response:**
```json
{
"success": true,
"data": [
{
"id": "model_abc123",
"name": "experiment-1",
"projectId": "project_xyz",
"trainedAt": "2024-01-15T10:00:00Z",
"metrics": {
"mAP50": 0.85,
"mAP50-95": 0.72
}
}
]
}
```
## Projects API
### List Projects
```
GET /api/projects
```
### Get Project
```
GET /api/projects/{projectId}
```
### Create Project
```
POST /api/projects
```
**Body:**
```json
{
"name": "my-project",
"description": "Detection experiments"
}
```
### Delete Project
```
DELETE /api/projects/{projectId}
```
## Models API
### List Models
```
GET /api/models
```
**Query Parameters:**
| Parameter | Type | Description |
| ----------- | ------ | ------------------- |
| `projectId` | string | Filter by project |
| `task` | string | Filter by task type |
### Get Model
```
GET /api/models/{modelId}
```
### Upload Model
```
POST /api/models
```
**Multipart Form:**
| Field | Type | Description |
| ----------- | ------ | -------------- |
| `file` | file | Model .pt file |
| `projectId` | string | Target project |
| `name` | string | Model name |
### Delete Model
```
DELETE /api/models/{modelId}
```
### Download Model
```
GET /api/models/{modelId}/files
```
Returns signed download URLs for model files.
### Run Inference
```
POST /api/models/{modelId}/predict
```
**Multipart Form:**
| Field | Type | Description |
| ------ | ----- | -------------------- |
| `file` | file | Image file |
| `conf` | float | Confidence threshold |
| `iou` | float | IoU threshold |
**Response:**
```json
{
"success": true,
"predictions": [
{
"class": "person",
"confidence": 0.92,
"box": { "x1": 100, "y1": 50, "x2": 300, "y2": 400 }
}
]
}
```
## Training API
### Start Training
```
POST /api/training/start
```
**Body:**
```json
{
"modelId": "model_abc123",
"datasetId": "dataset_xyz789",
"epochs": 100,
"imageSize": 640,
"gpuType": "rtx-4090"
}
```
### Get Training Status
```
GET /api/models/{modelId}/training
```
### Cancel Training
```
DELETE /api/models/{modelId}/training
```
## Deployments API
### List Deployments
```
GET /api/deployments
```
**Query Parameters:**
| Parameter | Type | Description |
| --------- | ------ | --------------- |
| `modelId` | string | Filter by model |
### Create Deployment
```
POST /api/deployments
```
**Body:**
```json
{
"modelId": "model_abc123",
"region": "us-central1",
"minInstances": 0,
"maxInstances": 10
}
```
### Get Deployment
```
GET /api/deployments/{deploymentId}
```
### Start Deployment
```
POST /api/deployments/{deploymentId}/start
```
### Stop Deployment
```
POST /api/deployments/{deploymentId}/stop
```
### Delete Deployment
```
DELETE /api/deployments/{deploymentId}
```
### Get Metrics
```
GET /api/deployments/{deploymentId}/metrics
```
### Get Logs
```
GET /api/deployments/{deploymentId}/logs
```
**Query Parameters:**
| Parameter | Type | Description |
| ---------- | ------ | -------------------- |
| `severity` | string | INFO, WARNING, ERROR |
| `limit` | int | Number of entries |
## Export API
### List Exports
```
GET /api/exports
```
### Create Export
```
POST /api/exports
```
**Body:**
```json
{
"modelId": "model_abc123",
"format": "onnx"
}
```
**Supported Formats:**
`onnx`, `torchscript`, `openvino`, `tensorrt`, `coreml`, `tflite`, `saved_model`, `graphdef`, `paddle`, `ncnn`, `edgetpu`, `tfjs`, `mnn`, `rknn`, `imx`, `axelera`, `executorch`
### Get Export Status
```
GET /api/exports/{exportId}
```
## Activity API
Track and manage activity events for your account.
### List Activity
```
GET /api/activity
```
**Query Parameters:**
| Parameter | Type | Description |
| ----------- | ------ | ------------------------ |
| `startDate` | string | Filter from date (ISO) |
| `endDate` | string | Filter to date (ISO) |
| `search` | string | Search in event messages |
### Mark Events Seen
```
POST /api/activity/mark-seen
```
### Archive Events
```
POST /api/activity/archive
```
## Trash API
Manage soft-deleted resources (30-day retention).
### List Trash
```
GET /api/trash
```
### Restore Item
```
POST /api/trash
```
**Body:**
```json
{
"itemId": "item_abc123",
"type": "dataset"
}
```
### Empty Trash
```
POST /api/trash/empty
```
Permanently deletes all items in trash.
## Billing API
Manage credits and subscriptions.
### Get Balance
```
GET /api/billing/balance
```
**Response:**
```json
{
"success": true,
"data": {
"cashBalance": 5000000,
"creditBalance": 20000000,
"reservedAmount": 0,
"totalBalance": 25000000
}
}
```
!!! note "Micro-USD"
All amounts are in micro-USD (1,000,000 = $1.00) for precise accounting.
### Get Usage Summary
```
GET /api/billing/usage-summary
```
Returns plan details, limits, and usage metrics.
### Create Checkout Session
```
POST /api/billing/checkout-session
```
**Body:**
```json
{
"amount": 25
}
```
Creates a Stripe checkout session for credit purchase ($5-$1000).
### Create Subscription Checkout
```
POST /api/billing/subscription-checkout
```
Creates a Stripe checkout session for Pro subscription.
### Create Portal Session
```
POST /api/billing/portal-session
```
Returns URL to Stripe billing portal for subscription management.
### Get Payment History
```
GET /api/billing/payments
```
Returns list of payment transactions from Stripe.
## Storage API
### Get Storage Info
```
GET /api/storage
```
**Response:**
```json
{
"success": true,
"data": {
"used": 1073741824,
"limit": 107374182400,
"percentage": 1.0
}
}
```
## GDPR API
GDPR compliance endpoints for data export and deletion.
### Export/Delete Account Data
```
POST /api/gdpr
```
**Body:**
```json
{
"action": "export"
}
```
| Action | Description |
| -------- | --------------------------- |
| `export` | Download all account data |
| `delete` | Delete account and all data |
!!! warning "Irreversible Action"
Account deletion is permanent and cannot be undone. All data, models, and deployments will be deleted.
## API Keys API
### List API Keys
```
GET /api/api-keys
```
### Create API Key
```
POST /api/api-keys
```
**Body:**
```json
{
"name": "training-server",
"scopes": ["training", "models"]
}
```
### Delete API Key
```
DELETE /api/api-keys/{keyId}
```
## Error Codes
| Code | Description |
| ------------------ | -------------------------- |
| `UNAUTHORIZED` | Invalid or missing API key |
| `FORBIDDEN` | Insufficient permissions |
| `NOT_FOUND` | Resource not found |
| `VALIDATION_ERROR` | Invalid request data |
| `RATE_LIMITED` | Too many requests |
| `INTERNAL_ERROR` | Server error |
## Python Integration
For easier integration, use the Ultralytics Python package.
### Installation & Setup
```bash
pip install ultralytics
```
Verify installation:
```bash
yolo check
```
!!! warning "Package Version Requirement"
Platform integration requires **ultralytics>=8.4.0**. Lower versions will NOT work with Platform.
### Authentication
**Method 1: CLI Configuration (Recommended)**
```bash
yolo settings api_key=YOUR_API_KEY
```
**Method 2: Environment Variable**
```bash
export ULTRALYTICS_API_KEY=YOUR_API_KEY
```
**Method 3: In Code**
```python
from ultralytics import settings
settings.api_key = "YOUR_API_KEY"
```
### Using Platform Datasets
Reference datasets with `ul://` URIs:
```python
from ultralytics import YOLO
model = YOLO("yolo11n.pt")
# Train on your Platform dataset
model.train(
data="ul://your-username/your-dataset",
epochs=100,
imgsz=640,
)
```
**URI Format:**
```
ul://{username}/{resource-type}/{name}
Examples:
ul://john/datasets/coco-custom # Dataset
ul://john/my-project # Project
ul://john/my-project/exp-1 # Specific model
ul://ultralytics/yolo26/yolo26n # Official model
```
### Pushing to Platform
Send results to a Platform project:
```python
from ultralytics import YOLO
model = YOLO("yolo11n.pt")
# Results automatically sync to Platform
model.train(
data="coco8.yaml",
epochs=100,
project="ul://your-username/my-project",
name="experiment-1",
)
```
**What syncs:**
- Training metrics (real-time)
- Final model weights
- Validation plots
- Console output
- System metrics
### API Examples
**Load a model from Platform:**
```python
# Your own model
model = YOLO("ul://username/project/model-name")
# Official model
model = YOLO("ul://ultralytics/yolo26/yolo26n")
```
**Run inference:**
```python
results = model("image.jpg")
# Access results
for r in results:
boxes = r.boxes # Detection boxes
masks = r.masks # Segmentation masks
keypoints = r.keypoints # Pose keypoints
probs = r.probs # Classification probabilities
```
**Export model:**
```python
# Export to ONNX
model.export(format="onnx", imgsz=640, half=True)
# Export to TensorRT
model.export(format="engine", imgsz=640, half=True)
# Export to CoreML
model.export(format="coreml", imgsz=640)
```
**Validation:**
```python
metrics = model.val(data="ul://username/my-dataset")
print(f"mAP50: {metrics.box.map50}")
print(f"mAP50-95: {metrics.box.map}")
```
## Webhooks
Webhooks notify your server of Platform events:
| Event | Description |
| -------------------- | -------------------- |
| `training.started` | Training job started |
| `training.epoch` | Epoch completed |
| `training.completed` | Training finished |
| `training.failed` | Training failed |
| `export.completed` | Export ready |
Webhook setup is available in Enterprise plans.
## FAQ
### How do I paginate large results?
Use `page` and `limit` parameters:
```bash
GET /api/datasets?page=2 &
limit=50
```
### Can I use the API without an SDK?
Yes, all functionality is available via REST. The SDK is a convenience wrapper.
### Are there API client libraries?
Currently, use the Ultralytics Python package or make direct HTTP requests. Official client libraries for other languages are planned.
### How do I handle rate limits?
Implement exponential backoff:
```python
import time
def api_request_with_retry(url, max_retries=3):
for attempt in range(max_retries):
response = requests.get(url)
if response.status_code != 429:
return response
wait = 2**attempt
time.sleep(wait)
raise Exception("Rate limit exceeded")
```

360
algorithms/dms_yolo/code/docs/en/platform/data/annotation.md Normal file
View File

@@ -0,0 +1,360 @@
---
comments: true
description: Learn to annotate images in Ultralytics Platform with manual tools, SAM smart annotation, and YOLO auto-labeling for all 5 task types.
keywords: Ultralytics Platform, annotation, labeling, SAM, auto-annotation, bounding box, polygon, keypoints, segmentation, YOLO
---
# Annotation Editor
[Ultralytics Platform](https://platform.ultralytics.com) includes a powerful annotation editor for labeling images with bounding boxes, polygons, keypoints, oriented boxes, and classifications. The editor supports manual annotation, SAM-powered smart annotation, and YOLO auto-labeling.
<!-- Screenshot: platform-annotate-toolbar.avif -->
```mermaid
graph TB
subgraph Manual["✏️ Manual Tools"]
A[Box] & B[Polygon] & C[Keypoint] & D[OBB] & E[Classify]
end
subgraph AI["🤖 AI-Assisted"]
F[SAM Smart] & G[Auto-Annotate]
end
Manual --> H[📁 Save Labels]
AI --> H
```
## Supported Task Types
The annotation editor supports all 5 YOLO task types:
| Task | Tool | Annotation Format |
| ------------ | -------------- | -------------------------------------- |
| **Detect** | Rectangle | Bounding boxes (x, y, width, height) |
| **Segment** | Polygon | Pixel-precise masks (polygon vertices) |
| **Pose** | Keypoint | 17-point COCO skeleton |
| **OBB** | Oriented Box | Rotated bounding boxes (4 corners) |
| **Classify** | Class Selector | Image-level labels |
### Task Details
??? info "Object Detection"
**What it does:** Identifies objects and their locations with axis-aligned bounding boxes.
**Label format:** `class_id center_x center_y width height` (all normalized 0-1)
**Example:** `0 0.5 0.5 0.2 0.3` — Class 0 centered at (50%, 50%) with 20% width and 30% height
**Use cases:** Inventory counting, traffic monitoring, wildlife detection, security systems
??? info "Instance Segmentation"
**What it does:** Creates pixel-precise masks for each object instance.
**Label format:** `class_id x1 y1 x2 y2 x3 y3 ...` (polygon vertices, normalized 0-1)
**Example:** `0 0.1 0.1 0.9 0.1 0.9 0.9 0.1 0.9` — Quadrilateral mask
**Use cases:** Medical imaging, autonomous vehicles, photo editing, agricultural analysis
??? info "Pose Estimation"
**What it does:** Detects body keypoints for skeleton tracking.
**Label format:** `class_id cx cy w h kx1 ky1 v1 kx2 ky2 v2 ...`
- Visibility flags: `0`=not labeled, `1`=labeled but occluded, `2`=labeled and visible
**Example:** `0 0.5 0.5 0.2 0.3 0.6 0.7 2 0.4 0.8 1` — Person with 2 keypoints
**Use cases:** Sports analysis, physical therapy, animation, gesture recognition
??? info "Oriented Bounding Box (OBB)"
**What it does:** Detects rotated objects with angle-aware bounding boxes.
**Label format:** `class_id x1 y1 x2 y2 x3 y3 x4 y4` (four corner points, normalized)
**Example:** `0 0.1 0.1 0.9 0.1 0.9 0.9 0.1 0.9` — Rotated rectangle
**Use cases:** Aerial imagery, document analysis, manufacturing inspection, ship detection
??? info "Image Classification"
**What it does:** Assigns a single label to the entire image.
**Label format:** Folder-based — images organized by class name (`train/cats/`, `train/dogs/`)
**Use cases:** Content moderation, quality control, medical diagnosis, scene recognition
## Getting Started
To annotate images:
1. Navigate to your dataset
2. Click on an image to open the fullscreen viewer
3. Click **Edit** to enter annotation mode
4. Select your annotation tool
5. Draw annotations on the image
6. Click **Save** when finished
<!-- Screenshot: platform-annotate-detect.avif -->
## Manual Annotation Tools
### Bounding Box (Detect)
Draw rectangular boxes around objects:
1. Select the **Box** tool or press `B`
2. Click and drag to draw a rectangle
3. Release to complete the box
4. Select a class from the dropdown
<!-- Screenshot: platform-annotate-detect.avif -->
!!! tip "Resize and Move"
- Drag corners or edges to resize
- Drag the center to move
- Press `Delete` to remove selected annotation
### Polygon (Segment)
Draw precise polygon masks:
1. Select the **Polygon** tool or press `P`
2. Click to add vertices
3. Double-click or press `Enter` to close the polygon
4. Select a class from the dropdown
<!-- Screenshot: platform-annotate-segment.avif -->
!!! tip "Edit Vertices"
- Drag individual vertices to adjust
- Drag the entire polygon to move
- Click on a vertex and press `Delete` to remove it
### Keypoint (Pose)
Place 17 COCO keypoints for human pose:
1. Select the **Keypoint** tool or press `K`
2. Click to place keypoints in sequence
3. Follow the COCO skeleton order
The 17 COCO keypoints are:
| # | Keypoint | # | Keypoint |
| --- | -------------- | --- | ----------- |
| 1 | Nose | 10 | Right wrist |
| 2 | Left eye | 11 | Left hip |
| 3 | Right eye | 12 | Right hip |
| 4 | Left ear | 13 | Left knee |
| 5 | Right ear | 14 | Right knee |
| 6 | Left shoulder | 15 | Left ankle |
| 7 | Right shoulder | 16 | Right ankle |
| 8 | Left elbow | 17 | (reserved) |
| 9 | Right elbow | | |
<!-- Screenshot: platform-annotate-pose.avif -->
### Oriented Bounding Box (OBB)
Draw rotated boxes for angled objects:
1. Select the **OBB** tool or press `O`
2. Click and drag to draw an initial box
3. Use the rotation handle to adjust angle
4. Select a class from the dropdown
<!-- Screenshot: platform-annotate-obb.avif -->
### Classification (Classify)
Assign image-level class labels:
1. Select the **Classify** mode
2. Click on class buttons or press number keys `1-9`
3. Multiple classes can be assigned per image
<!-- Screenshot: platform-annotate-classify.avif -->
## SAM Smart Annotation
[Segment Anything Model (SAM)](https://docs.ultralytics.com/models/sam/) enables intelligent annotation with just a few clicks:
1. Select **SAM** mode or press `S`
2. **Left-click** to add positive points (include this area)
3. **Right-click** to add negative points (exclude this area)
4. SAM generates a precise mask in real-time
5. Click **Accept** to convert to annotation
<!-- Screenshot: platform-annotate-sam.avif -->
!!! tip "SAM Tips"
- Start with a positive click on the object center
- Add negative clicks to exclude background
- Works best for distinct objects with clear edges
<!-- Screenshot: platform-annotate-sam-mask.avif -->
SAM smart annotation can generate:
- **Polygons** for segmentation tasks
- **Bounding boxes** for detection tasks
- **Oriented boxes** for OBB tasks
## YOLO Auto-Annotation
Use trained YOLO models to automatically label images:
1. Select **Auto-Annotate** mode or press `A`
2. Choose a model (official or your trained models)
3. Set confidence threshold
4. Click **Run** to generate predictions
5. Review and edit results as needed
<!-- Screenshot: platform-annotate-auto.avif -->
!!! note "Auto-Annotation Models"
You can use:
- Official Ultralytics models (YOLO26n, YOLO26s, etc.)
- Your own trained models from the Platform
## Class Management
### Creating Classes
Define annotation classes for your dataset:
1. Click **Add Class** in the class panel
2. Enter the class name
3. A color is assigned automatically
<!-- Screenshot: platform-annotate-classes.avif -->
### Add New Class During Annotation
You can create new classes directly while annotating without leaving the editor:
1. Draw an annotation on the image
2. In the class dropdown, click **Add New Class**
3. Enter the class name
4. Press Enter to create and assign
This allows for a seamless workflow where you can define classes as you encounter new object types in your data.
!!! tip "Unified Classes Table"
All classes across your dataset are managed in a unified table. Changes to class names or colors apply throughout the entire dataset automatically.
### Editing Classes
- Click on a class to select it for new annotations
- Double-click to rename
- Drag to reorder
- Right-click for more options
### Class Colors
Each class is assigned a color from the Ultralytics palette. Colors are consistent across the Platform for easy recognition.
## Keyboard Shortcuts
Efficient annotation with keyboard shortcuts:
| Shortcut | Action |
| -------- | -------------------------- |
| `B` | Box tool (detect) |
| `P` | Polygon tool (segment) |
| `K` | Keypoint tool (pose) |
| `O` | OBB tool |
| `S` | SAM smart annotation |
| `A` | Auto-annotate |
| `V` | Select/move mode |
| `1-9` | Select class 1-9 |
| `Delete` | Delete selected annotation |
| `Ctrl+Z` | Undo |
| `Ctrl+Y` | Redo |
| `Escape` | Cancel current operation |
| `Enter` | Complete polygon |
| `←/→` | Previous/next image |
<!-- Screenshot: platform-annotate-shortcuts.avif -->
??? tip "View All Shortcuts"
Press `?` to open the keyboard shortcuts dialog.
## Undo/Redo
The annotation editor maintains a full history:
- **Undo**: `Ctrl+Z` (Cmd+Z on Mac)
- **Redo**: `Ctrl+Y` (Cmd+Y on Mac)
History includes:
- Adding annotations
- Editing annotations
- Deleting annotations
- Changing classes
## Saving Annotations
Annotations are saved when you click **Save** or navigate away:
- **Save**: Click the save button or press `Ctrl+S`
- **Cancel**: Click cancel to discard changes
- **Auto-save warning**: Unsaved changes prompt before leaving
!!! warning "Save Your Work"
Always save before navigating to another image. Unsaved changes will be lost.
## FAQ
### How accurate is SAM annotation?
SAM provides high-quality masks for most objects. Accuracy depends on:
- Object distinctiveness from background
- Image quality and resolution
- Number of positive/negative points provided
For best results, start with a positive point on the object center and add negative points to exclude nearby objects.
### Can I import existing annotations?
Yes, upload your dataset with YOLO-format label files. The Platform automatically parses and displays them in the editor.
### How do I annotate multiple objects of the same class?
After drawing an annotation:
1. Keep the same class selected
2. Draw the next annotation
3. Repeat until all objects are labeled
The keyboard shortcut `1-9` quickly selects classes.
### What's the difference between SAM and auto-annotate?
| Feature | SAM | Auto-Annotate |
| ------------- | ----------------------------- | ----------------------------- |
| **Method** | Interactive point prompts | Model inference |
| **Speed** | One object at a time | All objects at once |
| **Precision** | Very high with guidance | Depends on model |
| **Best for** | Complex objects, fine details | Bulk labeling, simple objects |
### Can I train on partially annotated datasets?
Yes, but for best results:
- Label all objects of your target classes in each image
- Use the **unknown** split for unlabeled images
- Exclude unlabeled images from training configuration

317
algorithms/dms_yolo/code/docs/en/platform/data/datasets.md Normal file
View File

@@ -0,0 +1,317 @@
---
comments: true
description: Learn how to upload, manage, and organize datasets in Ultralytics Platform for YOLO model training with automatic processing and statistics.
keywords: Ultralytics Platform, datasets, dataset management, YOLO, data upload, training data, computer vision, machine learning
---
# Datasets
[Ultralytics Platform](https://platform.ultralytics.com) datasets provide a streamlined solution for managing your training data. Once uploaded, datasets can be immediately used for model training, with automatic processing and statistics generation.
## Upload Dataset
Ultralytics Platform accepts multiple upload formats for flexibility.
### Supported Image Formats
| Format | Extensions | Notes |
| ------ | --------------- | ------------------------ |
| JPEG | `.jpg`, `.jpeg` | Most common, recommended |
| PNG | `.png` | Supports transparency |
| WebP | `.webp` | Modern, good compression |
| BMP | `.bmp` | Uncompressed |
| GIF | `.gif` | First frame extracted |
| TIFF | `.tiff`, `.tif` | High quality |
| HEIC | `.heic` | iPhone photos |
| AVIF | `.avif` | Next-gen format |
| JP2 | `.jp2` | JPEG 2000 |
| DNG | `.dng` | Raw camera |
### Supported Video Formats
Videos are automatically extracted to frames:
| Format | Extensions | Extraction |
| ------ | ---------- | --------------------- |
| MP4 | `.mp4` | 1 FPS, max 100 frames |
| WebM | `.webm` | 1 FPS, max 100 frames |
| MOV | `.mov` | 1 FPS, max 100 frames |
| AVI | `.avi` | 1 FPS, max 100 frames |
| MKV | `.mkv` | 1 FPS, max 100 frames |
| M4V | `.m4v` | 1 FPS, max 100 frames |
### File Size Limits
| Type | Maximum Size |
| --------- | ------------ |
| Images | 50 MB each |
| Videos | 1 GB each |
| ZIP files | 50 GB |
### Archives
ZIP files up to 50GB are supported with folder structure preserved and automatic extraction and processing.
### Preparing Your Dataset
For labeled datasets, use the standard YOLO format:
```
my-dataset/
├── images/
│ ├── train/
│ │ ├── img001.jpg
│ │ └── img002.jpg
│ └── val/
│ ├── img003.jpg
│ └── img004.jpg
├── labels/
│ ├── train/
│ │ ├── img001.txt
│ │ └── img002.txt
│ └── val/
│ ├── img003.txt
│ └── img004.txt
└── data.yaml
```
The YAML file defines your dataset configuration:
```yaml
# data.yaml
path: .
train: images/train
val: images/val
names:
0: person
1: car
2: dog
```
### Upload Process
1. Navigate to **Datasets** in the sidebar
2. Click **Upload Dataset** or drag files into the upload zone
3. Select the task type (detect, segment, pose, OBB, classify)
4. Add a name and optional description
5. Click **Upload**
<!-- Screenshot: platform-datasets-upload.avif -->
After upload, the Platform processes your data:
1. **Normalization**: Large images resized (max 4096px)
2. **Thumbnails**: 256px previews generated
3. **Label Parsing**: YOLO format labels extracted
4. **Statistics**: Class distributions computed
<!-- Screenshot: platform-datasets-upload-progress.avif -->
??? tip "Validate Before Upload"
You can validate your dataset locally before uploading:
```python
from ultralytics.hub import check_dataset
check_dataset("path/to/dataset.zip", task="detect")
```
## Browse Images
View your dataset images in multiple layouts:
| View | Description |
| ----------- | ------------------------------------------------ |
| **Grid** | Thumbnail grid with annotation overlays |
| **Compact** | Smaller thumbnails for quick scanning |
| **Table** | List with filename, dimensions, and label counts |
<!-- Screenshot: platform-datasets-gallery.avif -->
### Fullscreen Viewer
Click any image to open the fullscreen viewer with:
- **Navigation**: Arrow keys or click to browse
- **Metadata**: Filename, dimensions, split, label count
- **Annotations**: Toggle annotation visibility
- **Class Breakdown**: Per-class label counts
<!-- Screenshot: platform-datasets-fullscreen.avif -->
### Filter by Split
Filter images by their dataset split:
| Split | Purpose |
| ----------- | ----------------------------------- |
| **Train** | Used for model training |
| **Val** | Used for validation during training |
| **Test** | Used for final evaluation |
| **Unknown** | No split assigned |
## Dataset Statistics
The **Statistics** tab provides automatic analysis of your dataset:
### Class Distribution
Bar chart showing the number of annotations per class:
<!-- Screenshot: platform-datasets-stats-class.avif -->
### Location Heatmap
Visualization of where annotations appear in images:
<!-- Screenshot: platform-datasets-stats-heatmap.avif -->
### Dimension Analysis
Scatter plot of image dimensions (width vs height):
<!-- Screenshot: platform-datasets-stats-dimensions.avif -->
!!! tip "Statistics Caching"
Statistics are cached for 5 minutes. Changes to annotations will be reflected after the cache expires.
## Export Dataset
Export your dataset in NDJSON format for offline use:
1. Open the dataset actions menu
2. Click **Export**
3. Download the NDJSON file
<!-- Screenshot: platform-datasets-export.avif -->
The NDJSON format stores one JSON object per line:
```json
{"filename": "img001.jpg", "split": "train", "labels": [...]}
{"filename": "img002.jpg", "split": "train", "labels": [...]}
```
See the [Ultralytics NDJSON format documentation](https://docs.ultralytics.com/datasets/detect/#ultralytics-ndjson-format) for full specification.
## Dataset URI
Reference Platform datasets using the `ul://` URI format:
```
ul://username/datasets/dataset-slug
```
Use this URI to train models from anywhere:
```bash
export ULTRALYTICS_API_KEY="your_api_key"
yolo train model=yolo26n.pt data=ul://username/datasets/my-dataset epochs=100
```
!!! example "Train Anywhere with Platform Data"
The `ul://` URI works from any environment:
- **Local machine**: Train on your hardware, data downloaded automatically
- **Google Colab**: Access your Platform datasets in notebooks
- **Remote servers**: Train on cloud VMs with full dataset access
## Visibility Settings
Control who can see your dataset:
| Setting | Description |
| ----------- | ------------------------------- |
| **Private** | Only you can access |
| **Public** | Anyone can view on Explore page |
<!-- Screenshot: platform-datasets-visibility.avif -->
To change visibility:
1. Open dataset actions menu
2. Click **Edit**
3. Toggle visibility setting
4. Click **Save**
## Edit Dataset
Update dataset name, description, or visibility:
1. Open dataset actions menu
2. Click **Edit**
3. Make changes
4. Click **Save**
## Delete Dataset
Delete a dataset you no longer need:
1. Open dataset actions menu
2. Click **Delete**
3. Confirm deletion
!!! note "Trash and Restore"
Deleted datasets are moved to Trash for 30 days. You can restore them from the Trash page in Settings.
## Train on Dataset
Start training directly from your dataset:
1. Click **Train Model** on the dataset page
2. Select a project or create new
3. Configure training parameters
4. Start training
See [Cloud Training](../train/cloud-training.md) for details.
## FAQ
### What happens to my data after upload?
Your data is processed and stored in your selected region (US, EU, or AP). Images are:
1. Validated for format and size
2. Normalized if larger than 4096px (preserving aspect ratio)
3. Stored using Content-Addressable Storage (CAS) with SHA-256 hashing
4. Thumbnails generated at 256px for fast browsing
### How does storage work?
Ultralytics Platform uses **Content-Addressable Storage (CAS)** for efficient storage:
- **Deduplication**: Identical images uploaded by different users are stored only once
- **Integrity**: SHA-256 hashing ensures data integrity
- **Efficiency**: Reduces storage costs and speeds up processing
- **Regional**: Data stays in your selected region (US, EU, or AP)
### Can I add images to an existing dataset?
Yes, use the **Add Images** button on the dataset page to upload additional images. New statistics will be computed automatically.
### How do I move images between datasets?
Use the bulk selection feature:
1. Select images in the gallery
2. Click **Move** or **Copy**
3. Select destination dataset
### What label formats are supported?
Ultralytics Platform supports YOLO format labels:
| Task | Format | Example |
| -------- | -------------------------------- | ----------------------------------- |
| Detect | `class cx cy w h` | `0 0.5 0.5 0.2 0.3` |
| Segment | `class x1 y1 x2 y2 ...` | `0 0.1 0.1 0.9 0.1 0.9 0.9` |
| Pose | `class cx cy w h kx1 ky1 v1 ...` | `0 0.5 0.5 0.2 0.3 0.6 0.7 2` |
| OBB | `class x1 y1 x2 y2 x3 y3 x4 y4` | `0 0.1 0.1 0.9 0.1 0.9 0.9 0.1 0.9` |
| Classify | Directory structure | `train/cats/`, `train/dogs/` |
All coordinates are normalized (0-1 range). Pose visibility flags: 0=not labeled, 1=labeled but occluded, 2=labeled and visible.

122
algorithms/dms_yolo/code/docs/en/platform/data/index.md Normal file
View File

@@ -0,0 +1,122 @@
---
comments: true
description: Learn about data management in Ultralytics Platform including dataset upload, annotation tools, and statistics visualization for YOLO model training.
keywords: Ultralytics Platform, data management, datasets, annotation, YOLO, computer vision, data preparation, labeling
---
# Data Preparation
Data preparation is the foundation of successful [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) models. [Ultralytics Platform](https://platform.ultralytics.com) provides comprehensive tools for managing your training data, from upload through annotation to analysis.
## Overview
The Data section of Ultralytics Platform helps you:
- **Upload** images, videos, and ZIP archives
- **Annotate** with manual tools and AI-assisted labeling
- **Analyze** your data with statistics and visualizations
- **Export** in standard formats for local training
<!-- Screenshot: platform-data-overview.avif -->
## Workflow
```mermaid
graph LR
A[📤 Upload] --> B[🏷️ Annotate]
B --> C[📊 Analyze]
C --> D[🚀 Train]
style A fill:#4CAF50,color:#fff
style B fill:#2196F3,color:#fff
style C fill:#FF9800,color:#fff
style D fill:#9C27B0,color:#fff
```
| Stage | Description |
| ------------ | ----------------------------------------------------------------------- |
| **Upload** | Import images, videos, or ZIP archives with automatic processing |
| **Annotate** | Label data with bounding boxes, polygons, keypoints, or classifications |
| **Analyze** | View class distributions, spatial heatmaps, and dimension statistics |
| **Export** | Download in NDJSON format for offline use |
## Supported Tasks
Ultralytics Platform supports all 5 YOLO task types:
| Task | Description | Annotation Tool |
| ------------ | ------------------------------------------- | ----------------- |
| **Detect** | Object detection with bounding boxes | Rectangle tool |
| **Segment** | Instance segmentation with pixel masks | Polygon tool |
| **Pose** | Keypoint estimation (17-point COCO format) | Keypoint tool |
| **OBB** | Oriented bounding boxes for rotated objects | Oriented box tool |
| **Classify** | Image-level classification | Class selector |
## Key Features
### Smart Storage
Ultralytics Platform uses efficient storage technology:
- **Deduplication**: Identical images stored only once
- **Integrity**: Checksums ensure data integrity
- **Efficiency**: Optimized storage and fast processing
### Dataset URIs
Reference datasets using the `ul://` URI format:
```bash
yolo train data=ul://username/datasets/my-dataset
```
This allows training on Platform datasets from any machine with your API key configured.
### Statistics and Visualization
Every dataset includes automatic statistics:
- **Class Distribution**: Bar chart of label counts per class
- **Location Heatmap**: Spatial distribution of annotations
- **Dimension Analysis**: Image width vs height distribution
- **Split Breakdown**: Train/validation/test sample counts
## Quick Links
- [**Datasets**](datasets.md): Upload and manage your training data
- [**Annotation**](annotation.md): Label data with manual and AI-assisted tools
## FAQ
### What file formats are supported for upload?
Ultralytics Platform supports:
**Images:** JPEG, PNG, WebP, BMP, GIF, TIFF, HEIC, AVIF, JP2, DNG (max 50MB each)
**Videos:** MP4, WebM, MOV, AVI, MKV, M4V (max 1GB, frames extracted at 1 FPS, max 100 frames)
**Archives:** ZIP files (max 50GB) containing images with optional YOLO-format labels
### What is the maximum dataset size?
Storage limits depend on your plan:
| Plan | Storage Limit |
| ---------- | ------------- |
| Free | 100 GB |
| Pro | 500 GB |
| Enterprise | Custom |
Individual file limits: Images 50MB, Videos 1GB, ZIP archives 50GB
### Can I use my Platform datasets for local training?
Yes! Use the dataset URI format to train locally:
```bash
export ULTRALYTICS_API_KEY="your_key"
yolo train data=ul://username/datasets/my-dataset epochs=100
```
Or export your dataset in NDJSON format for fully offline training.

292
algorithms/dms_yolo/code/docs/en/platform/deploy/endpoints.md Normal file
View File

@@ -0,0 +1,292 @@
---
comments: true
description: Deploy YOLO models to dedicated endpoints in 43 global regions with auto-scaling and monitoring on Ultralytics Platform.
keywords: Ultralytics Platform, deployment, endpoints, YOLO, production, scaling, global regions
---
# Dedicated Endpoints
[Ultralytics Platform](https://platform.ultralytics.com) enables deployment of YOLO models to dedicated endpoints in 43 global regions. Each endpoint is a single-tenant service with auto-scaling, custom URLs, and independent monitoring.
<!-- Screenshot: platform-deploy-tab.avif -->
## Create Endpoint
Deploy a model to a dedicated endpoint:
1. Navigate to your model
2. Click the **Deploy** tab
3. Select a region from the map
4. Click **Deploy**
### Region Selection
Choose from 43 regions worldwide:
<!-- Screenshot: platform-deploy-map.avif -->
The interactive map shows:
- **Region pins**: Click to select
- **Latency indicators**: Color-coded by distance
- Green: <100ms
- Yellow: 100-200ms
- Red: >200ms
### Region Table
View all regions with details:
<!-- Screenshot: platform-deploy-regions.avif -->
| Column | Description |
| ------------ | ------------------ |
| **Region** | Region identifier |
| **Location** | City/country |
| **Latency** | Measured ping time |
| **Status** | Available/deployed |
!!! tip "Choose Wisely"
Select the region closest to your users for lowest latency. Consider deploying to multiple regions for global coverage.
## Available Regions
### Americas (14 regions)
| Zone | Location |
| ----------------------- | ------------------- |
| us-central1 | Iowa, USA |
| us-east1 | South Carolina, USA |
| us-east4 | Virginia, USA |
| us-east5 | Ohio, USA |
| us-west1 | Oregon, USA |
| us-west2 | Los Angeles, USA |
| us-west3 | Salt Lake City, USA |
| us-west4 | Las Vegas, USA |
| us-south1 | Dallas, USA |
| northamerica-northeast1 | Montreal, Canada |
| northamerica-northeast2 | Toronto, Canada |
| southamerica-east1 | São Paulo, Brazil |
| southamerica-west1 | Santiago, Chile |
### Europe (12 regions)
| Zone | Location |
| ----------------- | ------------------- |
| europe-west1 | Belgium |
| europe-west2 | London, UK |
| europe-west3 | Frankfurt, Germany |
| europe-west4 | Netherlands |
| europe-west6 | Zurich, Switzerland |
| europe-west8 | Milan, Italy |
| europe-west9 | Paris, France |
| europe-west10 | Berlin, Germany |
| europe-west12 | Turin, Italy |
| europe-north1 | Finland |
| europe-central2 | Warsaw, Poland |
| europe-southwest1 | Madrid, Spain |
### Asia-Pacific (14 regions)
| Zone | Location |
| -------------------- | -------------------- |
| asia-east1 | Taiwan |
| asia-east2 | Hong Kong |
| asia-northeast1 | Tokyo, Japan |
| asia-northeast2 | Osaka, Japan |
| asia-northeast3 | Seoul, South Korea |
| asia-south1 | Mumbai, India |
| asia-south2 | Delhi, India |
| asia-southeast1 | Singapore |
| asia-southeast2 | Jakarta, Indonesia |
| australia-southeast1 | Sydney, Australia |
| australia-southeast2 | Melbourne, Australia |
### Middle East & Africa (3 regions)
| Zone | Location |
| ----------- | -------------------- |
| me-central1 | Doha, Qatar |
| me-central2 | Dammam, Saudi Arabia |
| me-west1 | Tel Aviv, Israel |
## Endpoint Configuration
When creating an endpoint:
<!-- Screenshot: platform-deploy-create.avif -->
| Setting | Description | Default |
| ----------------- | ------------------------- | ------- |
| **Region** | Deployment region | - |
| **Min Instances** | Minimum running instances | 0 |
| **Max Instances** | Maximum scaling limit | 10 |
### Scaling Options
| Setting | Behavior |
| ----------- | ---------------------------------------- |
| **Min = 0** | Scale to zero when idle (cost-effective) |
| **Min > 0** | Always-on for no cold starts |
| **Max** | Upper limit for traffic spikes |
!!! warning "Cold Starts"
With min instances = 0, the first request after idle triggers a cold start (2-5 seconds). Set min > 0 for latency-sensitive applications.
## Manage Endpoints
View and manage your endpoints:
<!-- Screenshot: platform-deploy-list.avif -->
### Endpoint Details
| Field | Description |
| ------------- | --------------------------- |
| **URL** | HTTPS endpoint for requests |
| **Region** | Deployed region |
| **Status** | Running, Stopped, Deploying |
| **Instances** | Current/max instance count |
### Endpoint URL
Each endpoint has a unique URL:
```
https://model-abc123-us-central1.a.run.app
```
<!-- Screenshot: platform-deploy-endpoint.avif -->
Click the copy button to copy the URL.
## Lifecycle Management
Control your endpoint state:
<!-- Screenshot: platform-deploy-lifecycle.avif -->
| Action | Description |
| ---------- | ------------------------------- |
| **Start** | Resume a stopped endpoint |
| **Stop** | Pause the endpoint (no billing) |
| **Delete** | Permanently remove endpoint |
### Stop Endpoint
Stop an endpoint to pause billing:
1. Open endpoint actions menu
2. Click **Stop**
3. Confirm action
Stopped endpoints:
- Don't accept requests
- Don't incur charges
- Can be restarted anytime
### Delete Endpoint
Permanently remove an endpoint:
1. Open endpoint actions menu
2. Click **Delete**
3. Confirm deletion
!!! warning "Permanent Action"
Deletion is immediate and permanent. You can always create a new endpoint.
## Using Endpoints
### Authentication
Include your API key in requests:
```bash
Authorization: Bearer YOUR_API_KEY
```
### Request Example
=== "cURL"
```bash
curl -X POST \
"https://model-abc123-us-central1.a.run.app/predict" \
-H "Authorization: Bearer YOUR_API_KEY" \
-F "file=@image.jpg"
```
=== "Python"
```python
import requests
url = "https://model-abc123-us-central1.a.run.app/predict"
headers = {"Authorization": "Bearer YOUR_API_KEY"}
files = {"file": open("image.jpg", "rb")}
response = requests.post(url, headers=headers, files=files)
print(response.json())
```
### Response Format
Same as [shared inference](inference.md#response) with task-specific fields.
## Pricing
Dedicated endpoints bill based on:
| Component | Rate |
| ------------ | -------------------- |
| **CPU** | Per vCPU-second |
| **Memory** | Per GB-second |
| **Requests** | Per million requests |
!!! tip "Cost Optimization"
- Use scale-to-zero for development endpoints
- Set appropriate max instances
- Monitor usage in the [Monitoring](monitoring.md) dashboard
## FAQ
### How many endpoints can I create?
There's no hard limit. Each model can have endpoints in multiple regions. Total endpoints depend on your plan.
### Can I change the region after deployment?
No, regions are fixed. To change regions:
1. Delete the existing endpoint
2. Create a new endpoint in the desired region
### How do I handle multi-region deployment?
For global coverage:
1. Deploy to multiple regions
2. Use a load balancer or DNS routing
3. Route users to the nearest endpoint
### What's the cold start time?
Cold start varies by model size:
| Model | Cold Start |
| ------- | ---------- |
| YOLO26n | ~2 seconds |
| YOLO26m | ~3 seconds |
| YOLO26x | ~5 seconds |
Set min instances > 0 to eliminate cold starts.
### Can I use custom domains?
Custom domains are coming soon. Currently, endpoints use platform-generated URLs.

146
algorithms/dms_yolo/code/docs/en/platform/deploy/index.md Normal file
View File

@@ -0,0 +1,146 @@
---
comments: true
description: Learn about model deployment options in Ultralytics Platform including inference testing, dedicated endpoints, and monitoring dashboards.
keywords: Ultralytics Platform, deployment, inference, endpoints, monitoring, YOLO, production, cloud deployment
---
# Deployment
[Ultralytics Platform](https://platform.ultralytics.com) provides comprehensive deployment options for putting your YOLO models into production. Test models with the inference API, deploy to dedicated endpoints, and monitor performance in real-time.
## Overview
The Deployment section helps you:
- **Test** models directly in the browser
- **Deploy** to dedicated endpoints in 43 global regions
- **Monitor** request metrics and logs
- **Scale** automatically with traffic
<!-- Screenshot: platform-deploy-overview.avif -->
## Deployment Options
Ultralytics Platform offers multiple deployment paths:
| Option | Description | Best For |
| ----------------------- | --------------------------------- | ----------------------- |
| **Test Tab** | Browser-based inference testing | Development, validation |
| **Shared API** | Multi-tenant inference service | Light usage, testing |
| **Dedicated Endpoints** | Single-tenant production services | Production, low latency |
## Workflow
```mermaid
graph LR
A[✅ Test] --> B[⚙️ Configure]
B --> C[🌐 Deploy]
C --> D[📊 Monitor]
style A fill:#4CAF50,color:#fff
style B fill:#2196F3,color:#fff
style C fill:#FF9800,color:#fff
style D fill:#9C27B0,color:#fff
```
| Stage | Description |
| ------------- | ----------------------------------- |
| **Test** | Validate model with sample images |
| **Configure** | Select region and scaling options |
| **Deploy** | Create dedicated endpoint |
| **Monitor** | Track requests, latency, and errors |
## Architecture
### Shared Inference
The shared inference service runs in 3 key regions:
| Region | Location |
| ------ | -------------------- |
| US | Iowa, USA |
| EU | Belgium, Europe |
| AP | Taiwan, Asia-Pacific |
Requests are routed to your data region automatically.
### Dedicated Endpoints
Deploy to 43 regions worldwide:
- **Americas**: 15 regions
- **Europe**: 12 regions
- **Asia Pacific**: 16 regions
Each endpoint is a single-tenant service with:
- Dedicated compute resources
- Auto-scaling (0-N instances)
- Custom URL
- Independent monitoring
## Key Features
### Global Coverage
Deploy close to your users with 43 regions covering:
- North America, South America
- Europe, Middle East, Africa
- Asia Pacific, Oceania
### Auto-Scaling
Endpoints scale automatically:
- **Scale to zero**: No cost when idle
- **Scale up**: Handle traffic spikes
- **Configurable limits**: Set min/max instances
### Low Latency
Dedicated endpoints provide:
- Cold start: ~2-5 seconds
- Warm inference: 50-200ms (model dependent)
- Regional routing for optimal performance
## Quick Links
- [**Inference**](inference.md): Test models in browser
- [**Endpoints**](endpoints.md): Deploy dedicated endpoints
- [**Monitoring**](monitoring.md): Track deployment performance
## FAQ
### What's the difference between shared and dedicated inference?
| Feature | Shared | Dedicated |
| ----------- | --------------- | -------------- |
| **Latency** | Variable | Consistent |
| **Cost** | Pay per request | Pay for uptime |
| **Scale** | Limited | Configurable |
| **Regions** | 3 | 43 |
| **URL** | Generic | Custom |
### How long does deployment take?
Dedicated endpoint deployment typically takes 1-2 minutes:
1. Image pull (~30s)
2. Container start (~30s)
3. Health check (~30s)
### Can I deploy multiple models?
Yes, each model can have multiple endpoints in different regions. There's no limit on total endpoints (subject to your plan).
### What happens when an endpoint is idle?
With scale-to-zero enabled:
- Endpoint scales down after inactivity
- First request triggers cold start
- Subsequent requests are fast
To avoid cold starts, set minimum instances > 0.

287
algorithms/dms_yolo/code/docs/en/platform/deploy/inference.md Normal file
View File

@@ -0,0 +1,287 @@
---
comments: true
description: Learn how to test YOLO models with the Ultralytics Platform inference API including browser testing and programmatic access.
keywords: Ultralytics Platform, inference, API, YOLO, object detection, prediction, testing
---
# Inference
[Ultralytics Platform](https://platform.ultralytics.com) provides an inference API for testing trained models. Use the browser-based Test tab for quick validation or the REST API for programmatic access.
<!-- Screenshot: platform-test-tab.avif -->
## Test Tab
Every model includes a Test tab for browser-based inference:
1. Navigate to your model
2. Click the **Test** tab
3. Upload an image or use examples
4. View predictions instantly
<!-- Screenshot: platform-test-upload.avif -->
### Upload Image
Drag and drop or click to upload:
- **Supported formats**: JPG, PNG, WebP, GIF
- **Max size**: 10MB
- **Auto-inference**: Results appear automatically
### Example Images
Use built-in example images for quick testing:
| Image | Content |
| ------------ | -------------------------- |
| `bus.jpg` | Street scene with vehicles |
| `zidane.jpg` | Sports scene with people |
### View Results
Inference results display:
- **Bounding boxes** with class labels
- **Confidence scores** for each detection
- **Class colors** matching your dataset
<!-- Screenshot: platform-test-results.avif -->
## Inference Parameters
Adjust detection behavior with parameters:
<!-- Screenshot: platform-test-params.avif -->
| Parameter | Range | Default | Description |
| -------------- | ------- | ------- | ---------------------------- |
| **Confidence** | 0.0-1.0 | 0.25 | Minimum confidence threshold |
| **IoU** | 0.0-1.0 | 0.70 | NMS IoU threshold |
| **Image Size** | 32-1280 | 640 | Input resize dimension |
### Confidence Threshold
Filter predictions by confidence:
- **Higher (0.5+)**: Fewer, more certain predictions
- **Lower (0.1-0.25)**: More predictions, some noise
- **Default (0.25)**: Balanced for most use cases
### IoU Threshold
Control Non-Maximum Suppression:
- **Higher (0.7+)**: Allow more overlapping boxes
- **Lower (0.3-0.5)**: Merge nearby detections more aggressively
- **Default (0.70)**: Balanced NMS behavior for most use cases
## REST API
Access inference programmatically:
### Authentication
Include your API key in requests:
```bash
Authorization: Bearer YOUR_API_KEY
```
### Endpoint
```
POST https://platform.ultralytics.com/api/models/{model_slug}/predict
```
### Request
=== "cURL"
```bash
curl -X POST \
"https://platform.ultralytics.com/api/models/username/project/model/predict" \
-H "Authorization: Bearer YOUR_API_KEY" \
-F "file=@image.jpg" \
-F "conf=0.25" \
-F "iou=0.7"
```
=== "Python"
```python
import requests
url = "https://platform.ultralytics.com/api/models/username/project/model/predict"
headers = {"Authorization": "Bearer YOUR_API_KEY"}
files = {"file": open("image.jpg", "rb")}
data = {"conf": 0.25, "iou": 0.7}
response = requests.post(url, headers=headers, files=files, data=data)
print(response.json())
```
<!-- Screenshot: platform-test-code.avif -->
### Response
```json
{
"success": true,
"predictions": [
{
"class": "person",
"confidence": 0.92,
"box": {
"x1": 100,
"y1": 50,
"x2": 300,
"y2": 400
}
},
{
"class": "car",
"confidence": 0.87,
"box": {
"x1": 400,
"y1": 200,
"x2": 600,
"y2": 350
}
}
],
"image": {
"width": 1920,
"height": 1080
}
}
```
<!-- Screenshot: platform-test-json.avif -->
### Response Fields
| Field | Type | Description |
| -------------------------- | ------- | -------------------------- |
| `success` | boolean | Request status |
| `predictions` | array | List of detections |
| `predictions[].class` | string | Class name |
| `predictions[].confidence` | float | Detection confidence (0-1) |
| `predictions[].box` | object | Bounding box coordinates |
| `image` | object | Original image dimensions |
### Task-Specific Responses
Response format varies by task:
=== "Detection"
```json
{
"class": "person",
"confidence": 0.92,
"box": {"x1": 100, "y1": 50, "x2": 300, "y2": 400}
}
```
=== "Segmentation"
```json
{
"class": "person",
"confidence": 0.92,
"box": {"x1": 100, "y1": 50, "x2": 300, "y2": 400},
"segments": [[100, 50], [150, 60], ...]
}
```
=== "Pose"
```json
{
"class": "person",
"confidence": 0.92,
"box": {"x1": 100, "y1": 50, "x2": 300, "y2": 400},
"keypoints": [
{"x": 200, "y": 75, "conf": 0.95},
...
]
}
```
=== "Classification"
```json
{
"predictions": [
{"class": "cat", "confidence": 0.95},
{"class": "dog", "confidence": 0.03}
]
}
```
## Rate Limits
Shared inference has rate limits:
| Plan | Requests/Minute | Requests/Day |
| ---- | --------------- | ------------ |
| Free | 10 | 100 |
| Pro | 60 | 10,000 |
For higher limits, deploy a [dedicated endpoint](endpoints.md).
## Error Handling
Common error responses:
| Code | Message | Solution |
| ---- | --------------- | -------------------- |
| 400 | Invalid image | Check file format |
| 401 | Unauthorized | Verify API key |
| 404 | Model not found | Check model slug |
| 429 | Rate limited | Wait or upgrade plan |
| 500 | Server error | Retry request |
## FAQ
### Can I run inference on video?
The API accepts individual frames. For video:
1. Extract frames locally
2. Send each frame to the API
3. Aggregate results
For real-time video, consider deploying a [dedicated endpoint](endpoints.md).
### How do I get the annotated image?
The API returns JSON predictions. To visualize:
1. Use predictions to draw boxes locally
2. Use Ultralytics `plot()` method:
```python
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
results = model("image.jpg")
results[0].save("annotated.jpg")
```
### What's the maximum image size?
- **Upload limit**: 10MB
- **Recommended**: <5MB for fast inference
- **Auto-resize**: Images are resized to `imgsz` parameter
Large images are automatically resized while preserving aspect ratio.
### Can I run batch inference?
The current API processes one image per request. For batch:
1. Send concurrent requests
2. Use a dedicated endpoint for higher throughput
3. Consider local inference for large batches

225
algorithms/dms_yolo/code/docs/en/platform/deploy/monitoring.md Normal file
View File

@@ -0,0 +1,225 @@
---
comments: true
description: Monitor deployed YOLO models on Ultralytics Platform with real-time metrics, request logs, and performance dashboards.
keywords: Ultralytics Platform, monitoring, metrics, logs, deployment, performance, YOLO, observability
---
# Monitoring
[Ultralytics Platform](https://platform.ultralytics.com) provides comprehensive monitoring for deployed endpoints. Track request metrics, view logs, and analyze performance in real-time.
<!-- Screenshot: platform-monitoring-page.avif -->
## Monitoring Dashboard
Access the global monitoring dashboard from the sidebar:
1. Click **Monitoring** in the sidebar
2. View all deployments at a glance
3. Click individual endpoints for details
### Overview Cards
<!-- Screenshot: platform-monitoring-cards.avif -->
| Metric | Description |
| ---------------------- | ----------------------------------- |
| **Total Requests** | Requests across all endpoints (24h) |
| **Active Deployments** | Currently running endpoints |
| **Error Rate** | Percentage of failed requests |
| **Avg Latency** | Mean response time |
### Deployments Table
<!-- Screenshot: platform-monitoring-table.avif -->
View all deployments with key metrics:
| Column | Description |
| ------------- | --------------------------- |
| **Model** | Model name with link |
| **Region** | Deployed region with flag |
| **Status** | Running/Stopped indicator |
| **Requests** | Request count (24h) |
| **Latency** | P50 response time |
| **Errors** | Error count (24h) |
| **Sparkline** | Traffic trend visualization |
!!! tip "Real-Time Updates"
The dashboard polls every 30 seconds. Click refresh for immediate updates.
## Endpoint Metrics
View detailed metrics for individual endpoints:
1. Navigate to your model's **Deploy** tab
2. Click on an endpoint
3. View the metrics panel
### Available Metrics
<!-- Screenshot: platform-monitoring-metrics.avif -->
| Metric | Description | Unit |
| ------------------- | -------------------------- | ----- |
| **Request Count** | Total requests over time | count |
| **Request Latency** | Response time distribution | ms |
| **Error Rate** | Failed request percentage | % |
| **Instance Count** | Active container instances | count |
| **CPU Utilization** | Processor usage | % |
| **Memory Usage** | RAM consumption | MB |
### Time Ranges
Select time range for metrics:
| Range | Description |
| ------- | ----------------------- |
| **1h** | Last hour |
| **6h** | Last 6 hours |
| **24h** | Last 24 hours (default) |
| **7d** | Last 7 days |
### Metric Charts
Interactive charts show:
- **Line graphs** for trends over time
- **Hover** for exact values
- **Zoom** to analyze specific periods
## Logs
View request logs for debugging:
<!-- Screenshot: platform-monitoring-logs.avif -->
### Log Entries
Each log entry shows:
| Field | Description |
| -------------- | -------------------- |
| **Timestamp** | Request time |
| **Severity** | INFO, WARNING, ERROR |
| **Message** | Log content |
| **Request ID** | Unique identifier |
### Severity Levels
Filter logs by severity:
| Level | Color | Description |
| ----------- | ------ | ------------------- |
| **INFO** | Blue | Normal requests |
| **WARNING** | Yellow | Non-critical issues |
| **ERROR** | Red | Failed requests |
### Log Filtering
Filter logs to find issues:
1. Select severity level
2. Search by keyword
3. Filter by time range
## Alerts
Set up alerts for endpoint issues (coming soon):
| Alert Type | Trigger |
| ------------------- | ------------------------- |
| **High Error Rate** | Error rate > threshold |
| **High Latency** | P95 latency > threshold |
| **No Requests** | Zero requests for period |
| **Scaling** | Instances at max capacity |
## Performance Optimization
Use monitoring data to optimize:
### High Latency
If latency is too high:
1. Check instance count (may need more)
2. Verify model size is appropriate
3. Consider closer region
4. Check image sizes being sent
### High Error Rate
If errors are occurring:
1. Review error logs for details
2. Check request format
3. Verify API key is valid
4. Check rate limits
### Scaling Issues
If hitting capacity:
1. Increase max instances
2. Set min instances > 0
3. Consider multiple regions
4. Optimize request batching
## Export Data
Export monitoring data for analysis:
1. Select time range
2. Click **Export**
3. Download CSV file
Export includes:
- Timestamp
- Request count
- Latency metrics
- Error counts
- Instance metrics
## FAQ
### How long is data retained?
| Data Type | Retention |
| ----------- | --------- |
| **Metrics** | 30 days |
| **Logs** | 7 days |
| **Alerts** | 90 days |
### Can I set up external monitoring?
Yes, endpoint URLs work with external monitoring tools:
- Uptime monitoring (Pingdom, UptimeRobot)
- APM tools (Datadog, New Relic)
- Custom health checks
### How accurate are the latency numbers?
Latency metrics measure:
- **P50**: Median response time
- **P95**: 95th percentile
- **P99**: 99th percentile
These represent server-side processing time, not including network latency to your users.
### Why are my metrics delayed?
Metrics have a ~2 minute delay due to:
- Metrics aggregation pipeline
- Aggregation windows
- Dashboard caching
For real-time debugging, check logs which are near-instant.
### Can I monitor multiple endpoints together?
Yes, the global monitoring dashboard shows all endpoints. Use the table to compare performance across deployments.

254
algorithms/dms_yolo/code/docs/en/platform/explore.md Normal file
View File

@@ -0,0 +1,254 @@
---
comments: true
description: Discover public datasets, models, and projects on the Ultralytics Platform for computer vision and YOLO applications.
keywords: Ultralytics Platform, explore, public datasets, public models, computer vision, YOLO
---
# Explore
[Ultralytics Platform](https://platform.ultralytics.com) Explore page showcases public content from the community. Discover datasets, models, and projects for inspiration and learning.
<!-- Screenshot: platform-explore-page.avif -->
```mermaid
graph LR
A[🔍 Browse] --> B[📥 Clone/Fork]
B --> C[✏️ Customize]
C --> D[🚀 Train]
style A fill:#4CAF50,color:#fff
style B fill:#2196F3,color:#fff
style C fill:#FF9800,color:#fff
style D fill:#9C27B0,color:#fff
```
## Overview
The Explore page features:
- **Public Datasets**: Community training data
- **Public Models**: Trained checkpoints ready to use
- **Public Projects**: Complete experiments and workflows
- **User Profiles**: Creators and their contributions
## Browse Content
### Content Types
| Type | Description |
| ------------ | -------------------------------------- |
| **Datasets** | Labeled image collections for training |
| **Models** | Trained YOLO checkpoints |
| **Projects** | Organized model collections |
### Filtering
Filter content to find what you need:
<!-- Screenshot: platform-explore-search.avif -->
| Filter | Options |
| -------- | ------------------------------------ |
| **Type** | Datasets, Models, Projects |
| **Task** | Detect, Segment, Pose, OBB, Classify |
| **Sort** | Recent, Popular, Most Downloaded |
### Search
Search by:
- Content name
- Description keywords
- Creator username
- Class names
## Content Cards
Each item displays:
<!-- Screenshot: platform-explore-cards.avif -->
| Element | Description |
| ------------- | ----------------------- |
| **Thumbnail** | Preview image |
| **Name** | Content title |
| **Creator** | Author with avatar |
| **Stats** | Downloads, views, likes |
| **Task** | YOLO task type badge |
## Use Public Content
### Clone Dataset
Use a public dataset for your training:
1. Click on the dataset
2. Click **Clone**
3. Dataset copies to your account
Cloned datasets:
- Are private by default
- Can be modified
- Don't affect the original
### Download Model
Download a public model:
1. Click on the model
2. Click **Download**
3. Select format (PT, ONNX, etc.)
### Fork Project
Copy a public project:
1. Click on the project
2. Click **Fork**
3. Project copies with all models
## Official Ultralytics Models
Featured at the top of Explore, you'll find official Ultralytics models:
| Project | Description | Models |
| ---------- | --------------------------- | ---------------------------- |
| **YOLO26** | Latest January 2026 release | 27 models (all sizes, tasks) |
| **YOLO11** | Current stable release | 10+ models |
| **YOLOv8** | Previous generation | Various |
| **YOLOv5** | Legacy, widely adopted | Various |
**Project Cards Show:**
- Project icon and name
- Public badge
- Creator avatar and username
- Short description
- Model count and total size
- Last updated
- Model name tags
**Dataset Cards Show:**
- Dataset name
- Task type badge
- Creator info
- Image count
- Preview thumbnails
## User Profiles
View public profiles:
<!-- Screenshot: platform-explore-profile.avif -->
| Section | Content |
| ----------- | --------------------------------- |
| **Bio** | User description |
| **Stats** | Contributions count |
| **Content** | Public datasets, models, projects |
| **Links** | Social profiles |
### Follow Users
Follow creators to:
- See their new content
- Get notifications
- Build your network
## Make Your Content Public
Make your work available to the community:
### Make Dataset Public
1. Go to your dataset
2. Open actions menu
3. Click **Edit**
4. Set visibility to **Public**
5. Click **Save**
### Make Model Public
1. Go to your model
2. Open actions menu
3. Click **Edit**
4. Set visibility to **Public**
5. Click **Save**
!!! tip "Quality Content"
Before making content public:
- Add clear descriptions
- Include class names
- Verify data quality
- Test model performance
## Guidelines
When contributing public content:
### Do
- Provide useful, high-quality content
- Write clear descriptions
- Include relevant metadata
- Respond to questions
- Credit data sources
### Don't
- Upload sensitive/private data
- Violate copyrights
- Upload inappropriate content
- Spam low-quality content
- Misrepresent performance
## FAQ
### Can I use public content commercially?
Check individual content licenses. Most community content is for:
- Research and education
- Personal projects
- Non-commercial use
Contact creators for commercial licensing.
### How do I report inappropriate content?
1. Click the report button on the content
2. Select violation type
3. Add details
4. Submit report
Our team reviews reports within 24-48 hours.
### Can I make public content private again?
Yes, you can change visibility anytime:
1. Open content settings
2. Change visibility to **Private**
3. Save changes
Existing clones/forks are not affected.
### How do I get featured?
Featured content is selected based on:
- Quality and usefulness
- Community engagement
- Novelty and interest
- Clear documentation
There's no application process - just create great content!
### Can I monetize public content?
Currently, the Platform doesn't support monetization. This may be added in future updates.

293
algorithms/dms_yolo/code/docs/en/platform/index.md Normal file
View File

@@ -0,0 +1,293 @@
---
comments: true
description: Ultralytics Platform is an end-to-end computer vision platform for data preparation, model training, and deployment with multi-region infrastructure.
keywords: Ultralytics Platform, YOLO, computer vision, model training, cloud deployment, annotation, inference, YOLO11, YOLO26, machine learning
---
# Ultralytics Platform
<div align="center">
<a href="https://docs.ultralytics.com/zh/platform/">中文</a> |
<a href="https://docs.ultralytics.com/ko/platform/">한국어</a> |
<a href="https://docs.ultralytics.com/ja/platform/">日本語</a> |
<a href="https://docs.ultralytics.com/ru/platform/">Русский</a> |
<a href="https://docs.ultralytics.com/de/platform/">Deutsch</a> |
<a href="https://docs.ultralytics.com/fr/platform/">Français</a> |
<a href="https://docs.ultralytics.com/es/platform/">Español</a> |
<a href="https://docs.ultralytics.com/pt/platform/">Português</a> |
<a href="https://docs.ultralytics.com/tr/platform/">Türkçe</a> |
<a href="https://docs.ultralytics.com/vi/platform/">Tiếng Việt</a> |
<a href="https://docs.ultralytics.com/ar/platform/">العربية</a>
<br>
<br>
<a href="https://discord.com/invite/ultralytics"><img alt="Discord" src="https://img.shields.io/discord/1089800235347353640?logo=discord&logoColor=white&label=Discord&color=blue"></a> <a href="https://community.ultralytics.com/"><img alt="Ultralytics Forums" src="https://img.shields.io/discourse/users?server=https%3A%2F%2Fcommunity.ultralytics.com&logo=discourse&label=Forums&color=blue"></a> <a href="https://www.reddit.com/r/ultralytics/"><img alt="Ultralytics Reddit" src="https://img.shields.io/reddit/subreddit-subscribers/ultralytics?style=flat&logo=reddit&logoColor=white&label=Reddit&color=blue"></a>
</div>
[Ultralytics Platform](https://platform.ultralytics.com) is a comprehensive end-to-end computer vision platform that streamlines the entire ML workflow from data preparation to model deployment. Built for teams and individuals who need production-ready [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) solutions without the infrastructure complexity.
![Ultralytics Platform Dataset Screenshot](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/dataset-screenshot.avif)
## What is Ultralytics Platform?
Ultralytics Platform is designed to replace fragmented ML tooling with a unified solution. It combines the capabilities of:
- **Roboflow** - Data management and annotation
- **Weights & Biases** - Experiment tracking
- **SageMaker** - Cloud training
- **HuggingFace** - Model deployment
- **Arize** - Monitoring
All in one platform with native support for YOLO26 and YOLO11 models.
## Workflow: Upload → Annotate → Train → Export → Deploy
The Platform provides an end-to-end workflow:
```mermaid
graph LR
subgraph Data["📁 Data"]
A[Upload] --> B[Annotate]
B --> C[Analyze]
end
subgraph Train["🚀 Train"]
D[Configure] --> E[Train on GPU]
E --> F[View Metrics]
end
subgraph Deploy["🌐 Deploy"]
G[Export] --> H[Deploy Endpoint]
H --> I[Monitor]
end
Data --> Train --> Deploy
```
| Stage | Features |
| ------------ | --------------------------------------------------------------------------- |
| **Upload** | Images (50MB), videos (1GB), ZIP archives (50GB) with automatic processing |
| **Annotate** | Manual tools, SAM smart annotation, YOLO auto-labeling for all 5 task types |
| **Train** | Cloud GPUs (RTX 4090 to H200), real-time metrics, project organization |
| **Export** | 17 deployment formats (ONNX, TensorRT, CoreML, TFLite, etc.) |
| **Deploy** | 43 global regions with dedicated endpoints, auto-scaling, monitoring |
**What you can do:**
- **Upload** images, videos, and ZIP archives to create training datasets
- **Visualize** annotations with interactive overlays for all 5 YOLO task types
- **Train** models on cloud GPUs (RTX 4090 to H200) with real-time metrics
- **Export** to 17 deployment formats (ONNX, TensorRT, CoreML, TFLite, etc.)
- **Deploy** to 43 global regions with one-click dedicated endpoints
- **Monitor** training progress, deployment health, and usage metrics
- **Collaborate** by making projects and datasets public for the community
## Multi-Region Infrastructure
Your data stays in your region. Ultralytics Platform operates infrastructure in three global regions:
| Region | Location | Best For |
| ------ | -------------------- | --------------------------------------- |
| **US** | Iowa, USA | Americas users, fastest for Americas |
| **EU** | Belgium, Europe | European users, GDPR compliance |
| **AP** | Taiwan, Asia-Pacific | Asia-Pacific users, lowest APAC latency |
You select your region during onboarding, and all your data, models, and deployments remain in that region.
## Key Features
### Data Preparation
- **Dataset Management**: Upload images, videos, or ZIP archives with automatic processing
- **Annotation Editor**: Manual annotation for all 5 YOLO task types (detect, segment, pose, OBB, classify)
- **SAM Smart Annotation**: Click-based intelligent annotation using Segment Anything Model
- **Auto-Annotation**: Use trained models to pre-label new data
- **Statistics**: Class distribution, location heatmaps, and dimension analysis
### Model Training
- **Cloud Training**: Train on cloud GPUs (RTX 4090, A100, H100) with real-time metrics
- **Remote Training**: Train anywhere and stream metrics to Platform (W&B-style)
- **Project Organization**: Group related models, compare experiments, track activity
- **17 Export Formats**: ONNX, TensorRT, CoreML, TFLite, and more
![Ultralytics Platform Project Screenshot](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/platform/project-screenshot.avif)
### Deployment
- **Inference Testing**: Test models directly in the browser with custom images
- **Dedicated Endpoints**: Deploy to 43 global regions with auto-scaling
- **Monitoring**: Real-time metrics, request logs, and performance dashboards
### Account Management
- **API Keys**: Secure key management for remote training and API access
- **Credits & Billing**: Pay-as-you-go training with transparent pricing
- **Activity Feed**: Track all account events and actions
- **Trash & Restore**: 30-day soft delete with item recovery
- **GDPR Compliance**: Data export and account deletion
## Quick Links
Get started with these resources:
- [**Quickstart**](quickstart.md): Create your first project and train a model in minutes
- [**Datasets**](data/datasets.md): Upload and manage your training data
- [**Annotation**](data/annotation.md): Label your data with manual and AI-assisted tools
- [**Projects**](train/projects.md): Organize your models and experiments
- [**Cloud Training**](train/cloud-training.md): Train on cloud GPUs
- [**Inference**](deploy/inference.md): Test your models
- [**Endpoints**](deploy/endpoints.md): Deploy models to production
- [**Monitoring**](deploy/monitoring.md): Track deployment performance
- [**API Keys**](account/api-keys.md): Manage API access
- [**Billing**](account/billing.md): Credits and payment
- [**Activity**](account/activity.md): Track account events
- [**Trash**](account/trash.md): Recover deleted items
- [**REST API**](api/index.md): API reference
## FAQ
### How do I get started with Ultralytics Platform?
To get started with [Ultralytics Platform](https://platform.ultralytics.com):
1. **Sign Up**: Create an account at [platform.ultralytics.com](https://platform.ultralytics.com)
2. **Select Region**: Choose your data region (US, EU, or AP) during onboarding
3. **Upload Dataset**: Navigate to the [Datasets](data/datasets.md) section to upload your data
4. **Train Model**: Create a project and start training on cloud GPUs
5. **Deploy**: Test your model and deploy to a dedicated endpoint
For a detailed guide, see the [Quickstart](quickstart.md) page.
### What are the benefits of Ultralytics Platform?
[Ultralytics Platform](https://platform.ultralytics.com) offers:
- **Unified Workflow**: Data, training, and deployment in one place
- **Multi-Region**: Data residency in US, EU, or AP regions
- **No-Code Training**: Train advanced YOLO models without writing code
- **Real-Time Metrics**: Stream training progress and monitor deployments
- **43 Deploy Regions**: Deploy models close to your users worldwide
- **5 Task Types**: Support for detection, segmentation, pose, OBB, and classification
- **AI-Assisted Annotation**: SAM and auto-labeling to speed up data preparation
### What GPU options are available for cloud training?
Ultralytics Platform supports multiple GPU types for cloud training:
| Tier | GPU | VRAM | Cost/Hour | Best For |
| ----------- | ------------ | ------ | --------- | -------------------------- |
| Budget | RTX A2000 | 6 GB | $0.12 | Small datasets, testing |
| Budget | RTX 3080 | 10 GB | $0.25 | Medium datasets |
| Budget | RTX 3080 Ti | 12 GB | $0.30 | Medium datasets |
| Budget | A30 | 24 GB | $0.44 | Larger batch sizes |
| Mid | RTX 4090 | 24 GB | $0.60 | Great price/performance |
| Mid | A6000 | 48 GB | $0.90 | Large models |
| Mid | L4 | 24 GB | $0.54 | Inference optimized |
| Mid | L40S | 48 GB | $1.72 | Large batch training |
| Pro | A100 40GB | 40 GB | $2.78 | Production training |
| Pro | A100 80GB | 80 GB | $3.44 | Very large models |
| Pro | H100 | 80 GB | $5.38 | Fastest training |
| Enterprise | H200 | 141 GB | $5.38 | Maximum performance |
| Enterprise | B200 | 192 GB | $10.38 | Largest models |
| Ultralytics | RTX PRO 6000 | 48 GB | $3.68 | Ultralytics infrastructure |
See [Cloud Training](train/cloud-training.md) for complete pricing and GPU options.
### How does remote training work?
You can train models anywhere and stream metrics to Platform.
!!! warning "Package Version Requirement"
Platform integration requires **ultralytics>=8.4.0**. Lower versions will NOT work with Platform.
```bash
pip install "ultralytics>=8.4.0"
```
```bash
# Set your API key
export ULTRALYTICS_API_KEY="your_api_key"
# Train with project/name to stream metrics
yolo train model=yolo26n.pt data=coco.yaml epochs=100 project=username/my-project name=exp1
```
See [Cloud Training](train/cloud-training.md) for more details on remote training.
### What annotation tools are available?
The Platform includes a full-featured annotation editor supporting:
- **Manual Tools**: Bounding boxes, polygons, keypoints, oriented boxes, classification
- **SAM Smart Annotation**: Click to generate precise masks using Segment Anything Model
- **YOLO Auto-Annotation**: Use trained models to pre-label images
- **Keyboard Shortcuts**: Efficient workflows with hotkeys
See [Annotation](data/annotation.md) for the complete guide.
## Troubleshooting
### Dataset Issues
| Problem | Solution |
| ---------------------- | -------------------------------------------------------------------------------------------------------- |
| Dataset won't process | Check file format is supported (JPEG, PNG, WebP, etc.). Max file size: images 50MB, videos 1GB, ZIP 50GB |
| Missing annotations | Verify labels are in YOLO format with `.txt` files matching image filenames |
| "Train split required" | Add `train/` folder to your dataset structure, or create splits in the dataset settings |
| Class names undefined | Add a `data.yaml` file with `names:` list, or define classes in dataset settings |
### Training Issues
| Problem | Solution |
| -------------------- | ----------------------------------------------------------------------------------- |
| Training won't start | Check credit balance in Settings > Billing. Minimum $5.00 required |
| Out of memory error | Reduce batch size, use smaller model (n/s), or select GPU with more VRAM |
| Poor metrics | Check dataset quality, increase epochs, try data augmentation, verify class balance |
| Training slow | Select faster GPU, reduce image size, check dataset isn't bottlenecked |
### Deployment Issues
| Problem | Solution |
| ----------------------- | -------------------------------------------------------------------------------------- |
| Endpoint not responding | Check endpoint status (Running vs Stopped). Cold start may take 2-5 seconds |
| 401 Unauthorized | Verify API key is correct and has required scopes |
| Slow inference | Check model size, consider TensorRT export, select closer region |
| Export failed | Some formats require specific model architectures. Try ONNX for broadest compatibility |
### Common Questions
??? question "Can I change my username after signup?"
No, usernames are permanent and cannot be changed. Choose carefully during signup.
??? question "Can I change my data region?"
No, data region is selected during signup and cannot be changed. To switch regions, create a new account and re-upload your data.
??? question "How do I get more credits?"
Go to Settings > Billing > Add Credits. Purchase credits from $5 to $1000. Purchased credits never expire.
??? question "What happens if training fails?"
You're only charged for completed compute time. Checkpoints are saved, and you can resume training.
??? question "Can I download my trained model?"
Yes, click the download icon on any model page to download the `.pt` file or exported formats.
??? question "How do I share my work publicly?"
Edit your project or dataset settings and toggle visibility to "Public". Public content appears on the Explore page.
??? question "What are the file size limits?"
Images: 50MB, Videos: 1GB, ZIP archives: 50GB. For larger files, split into multiple uploads.
??? question "How long are deleted items kept in Trash?"
30 days. After that, items are permanently deleted and cannot be recovered.
??? question "Can I use Platform models commercially?"
Free and Pro plans use AGPL license. For commercial use without AGPL requirements, contact sales@ultralytics.com for Enterprise licensing.

234
algorithms/dms_yolo/code/docs/en/platform/quickstart.md Normal file
View File

@@ -0,0 +1,234 @@
---
comments: true
description: Get started with Ultralytics Platform in minutes. Learn to create an account, upload datasets, train YOLO models, and deploy to production.
keywords: Ultralytics Platform, Quickstart, YOLO models, dataset upload, model training, cloud deployment, machine learning
---
# Ultralytics Platform Quickstart
[Ultralytics Platform](https://platform.ultralytics.com) is designed to be user-friendly and intuitive, allowing users to quickly upload their datasets and train new YOLO models. It offers a range of pretrained models to choose from, making it easy for users to get started. Once a model is trained, it can be tested directly in the browser and deployed to production with a single click.
```mermaid
journey
title Your First Model in 5 Minutes
section Sign Up
Create account: 5: User
Select region: 5: User
section Prepare Data
Upload dataset: 5: User
Review images: 4: User
section Train
Configure training: 5: User
Monitor progress: 3: Platform
section Deploy
Test model: 5: User
Deploy endpoint: 5: User
```
## Get Started
[Ultralytics Platform](https://platform.ultralytics.com) offers a variety of easy signup options. You can register and log in using your Google, Apple, or GitHub accounts, or simply with your email address.
<!-- Screenshot: platform-signup.avif -->
### Region Selection
During signup, you'll be asked to select your data region. This is an important choice as it determines where your data, models, and deployments will be stored.
<!-- Screenshot: platform-onboarding-region.avif -->
| Region | Location | Best For |
| ------ | -------------------- | --------------------------------------- |
| **US** | Iowa, USA | Americas users, fastest for Americas |
| **EU** | Belgium, Europe | European users, GDPR compliance |
| **AP** | Taiwan, Asia-Pacific | Asia-Pacific users, lowest APAC latency |
!!! warning "Region is Permanent"
Your region selection cannot be changed after account creation. Choose the region closest to you or your users for best performance.
### Free Credits
Every new account receives free credits for cloud GPU training:
| Email Type | Sign-up Credits | How to Qualify |
| ---------------------- | --------------- | -------------------------------------- |
| **Work/Company Email** | **$25.00** | Use your company domain (@company.com) |
| **Personal Email** | **$5.00** | Gmail, Yahoo, Outlook, etc. |
!!! tip "Maximize Your Credits"
Sign up with a work email to receive $25 in credits. If you signed up with a personal email, you can verify a work email later to unlock the additional $20 in credits.
### Complete Your Profile
After selecting your region, complete your profile with your information.
<!-- Screenshot: platform-onboarding-profile.avif -->
??? tip "Update Later"
You can update your profile anytime from the Settings page, including your display name, username, bio, and social links.
## Home Dashboard
After signing in, you will be directed to the Home page of [Ultralytics Platform](https://platform.ultralytics.com), which provides a comprehensive overview, quick actions, and recent activity.
<!-- Screenshot: platform-dashboard.avif -->
The sidebar provides access to all Platform sections:
**Top Section:**
| Item | Description |
| ----------- | ------------------------------------------------ |
| **Search** | Quick search across all your resources (Cmd+K) |
| **Home** | Dashboard with quick actions and recent activity |
| **Explore** | Discover public projects and datasets |
**My Workspace:**
| Section | Description |
| ------------ | --------------------------------------- |
| **Annotate** | Your datasets organized for annotation |
| **Train** | Your projects containing trained models |
| **Deploy** | Your active deployments |
**Bottom Section:**
| Item | Description |
| ------------ | --------------------------------------- |
| **Trash** | Deleted items (recoverable for 30 days) |
| **Settings** | Account, billing, and preferences |
| **Feedback** | Send feedback to Ultralytics |
### Quick Actions
From the Home page, you can quickly:
- **Upload Dataset**: Start preparing your training data
- **Create Project**: Organize a new set of experiments
- **Train Model**: Launch cloud training on GPUs
## Upload Your First Dataset
Navigate to Datasets and click "Upload Dataset" to add your training data.
<!-- Screenshot: platform-quickstart-upload.avif -->
Ultralytics Platform supports multiple upload formats:
| Format | Description |
| --------------- | ---------------------------------------------- |
| **Images** | JPG, PNG, WebP, TIFF, and other common formats |
| **ZIP Archive** | Compressed folder with images and labels |
| **Video** | MP4, AVI - frames extracted automatically |
| **YOLO Format** | Standard YOLO dataset structure with labels |
After upload, the Platform processes your data:
1. Images are normalized and thumbnails generated
2. Labels are parsed and validated
3. Statistics are computed automatically
Read more about [datasets](data/datasets.md) and supported formats.
## Create Your First Project
Projects help you organize related models and experiments. Navigate to Projects and click "Create Project".
<!-- Screenshot: platform-projects-create.avif -->
Enter a name and optional description for your project. Projects contain:
- **Models**: Trained checkpoints
- **Activity Log**: History of changes
Read more about [projects](train/projects.md).
## Train Your First Model
From your project, click "Train Model" to start cloud training.
<!-- Screenshot: platform-quickstart-train.avif -->
### Training Configuration
1. **Select Dataset**: Choose from your uploaded datasets
2. **Choose Model**: Select a base model (YOLO26n, YOLO26s, etc.)
3. **Set Epochs**: Number of training iterations
4. **Select GPU**: Choose compute resources
| Model | Size | Speed | Accuracy |
| ------- | ----------- | -------- | -------- |
| YOLO26n | Nano | Fastest | Good |
| YOLO26s | Small | Fast | Better |
| YOLO26m | Medium | Moderate | High |
| YOLO26l | Large | Slower | Higher |
| YOLO26x | Extra Large | Slowest | Best |
### Monitor Training
Once training starts, you can monitor progress in real-time:
- **Loss Curves**: Track training and validation loss
- **Metrics**: mAP, precision, recall updated each epoch
- **System Stats**: GPU utilization, memory usage
Read more about [cloud training](train/cloud-training.md).
## Test Your Model
After training completes, test your model directly in the browser:
1. Navigate to your model's **Test** tab
2. Upload an image or use example images
3. View inference results with bounding boxes
<!-- Screenshot: platform-test-tab.avif -->
Adjust inference parameters:
- **Confidence Threshold**: Filter low-confidence predictions
- **IoU Threshold**: Control overlap for NMS
- **Image Size**: Resize input for inference
Read more about [inference](deploy/inference.md).
## Deploy to Production
Deploy your model to a dedicated endpoint for production use:
1. Navigate to your model's **Deploy** tab
2. Select a region from the global map (43 available)
3. Click "Deploy" to create your endpoint
<!-- Screenshot: platform-deploy-tab.avif -->
Your endpoint will be ready in about a minute with:
- **Unique URL**: HTTPS endpoint for API calls
- **Auto-Scaling**: Scales with traffic automatically
- **Monitoring**: Request metrics and logs
Read more about [endpoints](deploy/endpoints.md).
## Feedback
We value your feedback! Use the feedback button to help us improve the platform.
??? info "Feedback Privacy"
Your feedback is private and only visible to the Ultralytics team. We use it to prioritize features and fix issues.
## Need Help?
If you encounter any issues or have questions:
- **Documentation**: Browse these docs for detailed guides
- **Discord**: Join our [Discord community](https://discord.com/invite/ultralytics) for discussions
- **GitHub**: Report issues on [GitHub](https://github.com/ultralytics/ultralytics/issues)
!!! note
When reporting a bug, please include your browser and operating system details to help us diagnose the issue.

372
algorithms/dms_yolo/code/docs/en/platform/train/cloud-training.md Normal file
View File

@@ -0,0 +1,372 @@
---
comments: true
description: Learn how to train YOLO models on cloud GPUs with Ultralytics Platform, including remote training and real-time metrics streaming.
keywords: Ultralytics Platform, cloud training, GPU training, remote training, YOLO, model training, machine learning
---
# Cloud Training
[Ultralytics Platform](https://platform.ultralytics.com) Cloud Training offers single-click training on cloud GPUs, making model training accessible without complex setup. Train YOLO models with real-time metrics streaming and automatic checkpoint saving.
## Train from UI
Start cloud training directly from the Platform:
1. Navigate to your project
2. Click **Train Model**
3. Configure training parameters
4. Click **Start Training**
### Step 1: Select Dataset
Choose a dataset from your uploads:
<!-- Screenshot: platform-training-start.avif -->
| Option | Description |
| ------------------- | ---------------------------- |
| **Your Datasets** | Datasets you've uploaded |
| **Public Datasets** | Public datasets from Explore |
### Step 2: Configure Model
Select base model and parameters:
| Parameter | Description | Default |
| -------------- | --------------------------------------- | ------- |
| **Model** | Base architecture (YOLO26n, s, m, l, x) | YOLO26n |
| **Epochs** | Number of training iterations | 100 |
| **Image Size** | Input resolution | 640 |
| **Batch Size** | Samples per iteration | Auto |
<!-- Screenshot: platform-training-config.avif -->
### Step 3: Select GPU
Choose your compute resources:
<!-- Screenshot: platform-training-gpu.avif -->
| Tier | GPU | VRAM | Price/Hour | Best For |
| ----------- | ------------ | ------ | ---------- | -------------------------- |
| Budget | RTX A2000 | 6 GB | $0.12 | Small datasets, testing |
| Budget | RTX 3080 | 10 GB | $0.25 | Medium datasets |
| Budget | RTX 3080 Ti | 12 GB | $0.30 | Medium datasets |
| Budget | A30 | 24 GB | $0.44 | Larger batch sizes |
| Mid | RTX 4090 | 24 GB | $0.60 | Great price/performance |
| Mid | A6000 | 48 GB | $0.90 | Large models |
| Mid | L4 | 24 GB | $0.54 | Inference optimized |
| Mid | L40S | 48 GB | $1.72 | Large batch training |
| Pro | A100 40GB | 40 GB | $2.78 | Production training |
| Pro | A100 80GB | 80 GB | $3.44 | Very large models |
| Pro | H100 | 80 GB | $5.38 | Fastest training |
| Enterprise | H200 | 141 GB | $5.38 | Maximum performance |
| Enterprise | B200 | 192 GB | $10.38 | Largest models |
| Ultralytics | RTX PRO 6000 | 48 GB | $3.68 | Ultralytics infrastructure |
!!! tip "GPU Selection"
- **RTX 4090**: Best price/performance ratio for most jobs at $0.60/hr
- **A100 80GB**: Required for large batch sizes or big models
- **H100/H200**: Maximum performance for time-sensitive training
- **B200**: NVIDIA Blackwell architecture for cutting-edge workloads
### Step 4: Start Training
Click **Start Training** to launch your job. The Platform:
1. Provisions a GPU instance
2. Downloads your dataset
3. Begins training
4. Streams metrics in real-time
!!! success "Free Credits"
New accounts receive $5 in signup credits ($25 for company emails) - enough for several training runs. [Check your balance](../account/billing.md) in Settings > Billing.
<!-- Screenshot: platform-training-progress.avif -->
## Monitor Training
View real-time training progress:
### Live Metrics
<!-- Screenshot: platform-training-realtime.avif -->
| Metric | Description |
| ------------- | ---------------------------- |
| **Loss** | Training and validation loss |
| **mAP** | Mean Average Precision |
| **Precision** | Correct positive predictions |
| **Recall** | Detected ground truths |
| **GPU Util** | GPU utilization percentage |
| **Memory** | GPU memory usage |
### Checkpoints
Checkpoints are saved automatically:
- **Every epoch**: Latest weights saved
- **Best model**: Highest mAP checkpoint preserved
- **Final model**: Weights at training completion
## Stop and Resume
### Stop Training
Click **Stop Training** to pause your job:
- Current checkpoint is saved
- GPU instance is released
- Credits stop being charged
### Resume Training
Continue from your last checkpoint:
1. Navigate to the model
2. Click **Resume Training**
3. Confirm continuation
!!! note "Resume Limitations"
You can only resume training that was explicitly stopped. Failed training jobs may need to restart from scratch.
## Remote Training
Train on your own hardware while streaming metrics to the Platform.
!!! warning "Package Version Requirement"
Platform integration requires **ultralytics>=8.4.0**. Lower versions will NOT work with Platform.
```bash
pip install "ultralytics>=8.4.0"
```
### Setup API Key
1. Go to Settings > API Keys
2. Create a new key with training scope
3. Set the environment variable:
```bash
export ULTRALYTICS_API_KEY="your_api_key"
```
### Train with Streaming
Use the `project` and `name` parameters to stream metrics:
=== "CLI"
```bash
yolo train model=yolo26n.pt data=coco.yaml epochs=100 \
project=username/my-project name=experiment-1
```
=== "Python"
```python
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
model.train(
data="coco.yaml",
epochs=100,
project="username/my-project",
name="experiment-1",
)
```
### Using Platform Datasets
Train with datasets stored on the Platform:
```bash
yolo train model=yolo26n.pt data=ul://username/datasets/my-dataset epochs=100
```
The `ul://` URI format automatically downloads and configures your dataset.
## Billing
Training costs are based on GPU usage:
### Cost Estimation
Before training starts, the Platform estimates total cost based on:
```
Estimated Cost = Base Time × Model Multiplier × Dataset Multiplier × GPU Speed Factor × GPU Rate
```
**Factors affecting cost:**
| Factor | Impact |
| -------------------- | ------------------------------------------------ |
| **Dataset Size** | More images = longer training time |
| **Model Size** | Larger models (m, l, x) train slower than (n, s) |
| **Number of Epochs** | Direct multiplier on training time |
| **Image Size** | Larger imgsz increases computation |
| **GPU Speed** | Faster GPUs reduce training time |
### Cost Examples
| Scenario | GPU | Time | Cost |
| --------------------------------- | --------- | -------- | ------- |
| 1000 images, YOLO26n, 100 epochs | RTX 4090 | ~1 hour | ~$0.60 |
| 5000 images, YOLO26m, 100 epochs | A100 80GB | ~4 hours | ~$13.76 |
| 10000 images, YOLO26x, 200 epochs | H100 | ~8 hours | ~$43.04 |
### Hold/Settle System
The Platform uses a consumer-protection billing model:
1. **Estimate**: Cost calculated before training starts
2. **Hold**: Estimated amount + 20% safety margin reserved from balance
3. **Train**: Reserved amount shown as "Reserved" in your balance
4. **Settle**: After completion, charged only for actual GPU time used
5. **Refund**: Any excess automatically returned to your balance
!!! success "Consumer Protection"
You're **never charged more than the estimate** shown before training. If training completes early or is canceled, you only pay for actual compute time used.
### Payment Methods
| Method | Description |
| ------------------- | ------------------------ |
| **Account Balance** | Pre-loaded credits |
| **Pay Per Job** | Charge at job completion |
!!! note "Minimum Balance"
A minimum balance of $5.00 is required to start epoch-based training.
### View Training Costs
After training, view detailed costs in the **Billing** tab:
- Per-epoch cost breakdown
- Total GPU time
- Download cost report
<!-- Screenshot: platform-training-complete.avif -->
## Training Tips
### Choose the Right Model Size
| Model | Parameters | Best For |
| ------- | ---------- | ----------------------- |
| YOLO26n | 2.4M | Real-time, edge devices |
| YOLO26s | 9.5M | Balanced speed/accuracy |
| YOLO26m | 20.4M | Higher accuracy |
| YOLO26l | 24.8M | Production accuracy |
| YOLO26x | 55.7M | Maximum accuracy |
### Optimize Training Time
1. **Start small**: Test with fewer epochs first
2. **Use appropriate GPU**: Match GPU to model/batch size
3. **Validate dataset**: Ensure quality before training
4. **Monitor early**: Stop if metrics plateau
### Troubleshooting
| Issue | Solution |
| -------------------- | ----------------------------------- |
| Training stuck at 0% | Check dataset format, retry |
| Out of memory | Reduce batch size or use larger GPU |
| Poor accuracy | Increase epochs, check data quality |
| Training slow | Consider faster GPU |
## FAQ
### How long does training take?
Training time depends on:
- Dataset size
- Model size
- Number of epochs
- GPU selected
Typical times (1000 images, 100 epochs):
| Model | RTX 4090 | A100 |
| ------- | -------- | ------ |
| YOLO26n | 30 min | 20 min |
| YOLO26m | 60 min | 40 min |
| YOLO26x | 120 min | 80 min |
### Can I train overnight?
Yes, training continues until completion. You'll receive a notification when training finishes. Make sure your account has sufficient balance for epoch-based training.
### What happens if I run out of credits?
Training pauses at the end of the current epoch. Your checkpoint is saved, and you can resume after adding credits.
### Can I use custom training arguments?
Yes, advanced users can specify additional arguments in the training configuration.
## Training Parameters Reference
### Core Parameters
| Parameter | Type | Default | Range | Description |
| ---------- | ---- | ------- | --------- | ------------------------- |
| `epochs` | int | 100 | 1+ | Number of training epochs |
| `batch` | int | 16 | -1 = auto | Batch size (-1 for auto) |
| `imgsz` | int | 640 | 32+ | Input image size |
| `patience` | int | 100 | 0+ | Early stopping patience |
| `workers` | int | 8 | 0+ | Dataloader workers |
| `cache` | bool | False | - | Cache images (ram/disk) |
### Learning Rate Parameters
| Parameter | Type | Default | Range | Description |
| --------------- | ----- | ------- | ------- | --------------------- |
| `lr0` | float | 0.01 | 0.0-1.0 | Initial learning rate |
| `lrf` | float | 0.01 | 0.0-1.0 | Final LR factor |
| `momentum` | float | 0.937 | 0.0-1.0 | SGD momentum |
| `weight_decay` | float | 0.0005 | 0.0-1.0 | L2 regularization |
| `warmup_epochs` | float | 3.0 | 0+ | Warmup epochs |
| `cos_lr` | bool | False | - | Cosine LR scheduler |
### Augmentation Parameters
| Parameter | Type | Default | Range | Description |
| ------------ | ----- | ------- | ------- | -------------------- |
| `hsv_h` | float | 0.015 | 0.0-1.0 | HSV hue augmentation |
| `hsv_s` | float | 0.7 | 0.0-1.0 | HSV saturation |
| `hsv_v` | float | 0.4 | 0.0-1.0 | HSV value |
| `degrees` | float | 0.0 | - | Rotation degrees |
| `translate` | float | 0.1 | 0.0-1.0 | Translation fraction |
| `scale` | float | 0.5 | 0.0-1.0 | Scale factor |
| `fliplr` | float | 0.5 | 0.0-1.0 | Horizontal flip prob |
| `flipud` | float | 0.0 | 0.0-1.0 | Vertical flip prob |
| `mosaic` | float | 1.0 | 0.0-1.0 | Mosaic augmentation |
| `mixup` | float | 0.0 | 0.0-1.0 | Mixup augmentation |
| `copy_paste` | float | 0.0 | 0.0-1.0 | Copy-paste (segment) |
### Optimizer Selection
| Value | Description |
| ------- | ----------------------------- |
| `auto` | Automatic selection (default) |
| `SGD` | Stochastic Gradient Descent |
| `Adam` | Adam optimizer |
| `AdamW` | Adam with weight decay |
!!! tip "Task-Specific Parameters"
Some parameters only apply to specific tasks:
- **Segment**: `overlap_mask`, `mask_ratio`, `copy_paste`
- **Pose**: `pose` (loss weight), `kobj` (keypoint objectness)
- **Classify**: `dropout`, `erasing`, `auto_augment`

128
algorithms/dms_yolo/code/docs/en/platform/train/index.md Normal file
View File

@@ -0,0 +1,128 @@
---
comments: true
description: Learn about model training in Ultralytics Platform including project organization, cloud training, and real-time metrics streaming.
keywords: Ultralytics Platform, model training, cloud training, YOLO, GPU training, machine learning, deep learning
---
# Model Training
[Ultralytics Platform](https://platform.ultralytics.com) provides comprehensive tools for training YOLO models, from organizing experiments to running cloud training jobs with real-time metrics streaming.
## Overview
The Training section helps you:
- **Organize** models into projects for easier management
- **Train** on cloud GPUs with a single click
- **Monitor** real-time metrics during training
- **Compare** model performance across experiments
<!-- Screenshot: platform-train-overview.avif -->
## Workflow
```mermaid
graph LR
A[📁 Project] --> B[⚙️ Configure]
B --> C[🚀 Train]
C --> D[📈 Monitor]
D --> E[📦 Export]
style A fill:#4CAF50,color:#fff
style B fill:#2196F3,color:#fff
style C fill:#FF9800,color:#fff
style D fill:#9C27B0,color:#fff
style E fill:#00BCD4,color:#fff
```
| Stage | Description |
| ------------- | --------------------------------------------------- |
| **Project** | Create a workspace to organize related models |
| **Configure** | Select dataset, base model, and training parameters |
| **Train** | Run on cloud GPUs or your local hardware |
| **Monitor** | View real-time loss curves and metrics |
| **Export** | Convert to 17 deployment formats |
## Training Options
Ultralytics Platform supports multiple training approaches:
| Method | Description | Best For |
| ------------------- | ------------------------------------------ | -------------------------- |
| **Cloud Training** | Train on Platform cloud GPUs | No local GPU, scalability |
| **Remote Training** | Train locally, stream metrics to Platform | Existing hardware, privacy |
| **Colab Training** | Use Google Colab with Platform integration | Free GPU access |
## GPU Options
Available GPUs for cloud training:
| Tier | GPU | VRAM | Cost/Hour | Best For |
| ---------- | ------------ | ------ | --------- | -------------------------- |
| Budget | RTX A2000 | 6 GB | $0.12 | Small datasets, testing |
| Budget | RTX 3080 | 10 GB | $0.25 | Medium datasets |
| Budget | RTX 3080 Ti | 12 GB | $0.30 | Medium datasets |
| Budget | A30 | 24 GB | $0.44 | Larger batch sizes |
| Mid | L4 | 24 GB | $0.54 | Inference optimized |
| Mid | RTX 4090 | 24 GB | $0.60 | Great price/performance |
| Mid | A6000 | 48 GB | $0.90 | Large models |
| Mid | L40S | 48 GB | $1.72 | Large batch training |
| Pro | A100 40GB | 40 GB | $2.78 | Production training |
| Pro | A100 80GB | 80 GB | $3.44 | Very large models |
| Pro | RTX PRO 6000 | 48 GB | $3.68 | Ultralytics infrastructure |
| Pro | H100 | 80 GB | $5.38 | Fastest training |
| Enterprise | H200 | 141 GB | $5.38 | Maximum performance |
| Enterprise | B200 | 192 GB | $10.38 | Largest models |
!!! tip "Signup Credits"
New accounts receive signup credits for training. Check [Billing](../account/billing.md) for details.
## Real-Time Metrics
During training, view live metrics:
- **Loss Curves**: Box, class, and DFL loss
- **Performance**: mAP50, mAP50-95, precision, recall
- **System Stats**: GPU utilization, memory usage
- **Checkpoints**: Automatic saving of best weights
## Quick Links
- [**Projects**](projects.md): Organize your models and experiments
- [**Models**](models.md): Manage trained checkpoints
- [**Cloud Training**](cloud-training.md): Train on cloud GPUs
## FAQ
### How long does training take?
Training time depends on:
- Dataset size (number of images)
- Model size (n, s, m, l, x)
- Number of epochs
- GPU type selected
A typical training run with 1000 images, YOLO26n, 100 epochs on RTX 4090 takes about 30-60 minutes.
### Can I train multiple models simultaneously?
Cloud training currently supports one concurrent training job per account. For parallel training, use remote training from multiple machines.
### What happens if training fails?
If training fails:
1. Checkpoints are saved at each epoch
2. You can resume from the last checkpoint
3. Credits are only charged for completed compute time
### How do I choose the right GPU?
| Scenario | Recommended GPU |
| ----------------------------------- | ----------------- |
| Small datasets (<5000 images) | RTX 4090 |
| Medium datasets (5000-50000 images) | A100 40GB |
| Large datasets or batch sizes | A100 80GB or H100 |
| Budget-conscious | RTX 3090 |

237
algorithms/dms_yolo/code/docs/en/platform/train/models.md Normal file
View File

@@ -0,0 +1,237 @@
---
comments: true
description: Learn how to manage, analyze, and export trained models in Ultralytics Platform with support for 17 deployment formats.
keywords: Ultralytics Platform, models, model management, export, ONNX, TensorRT, CoreML, YOLO
---
# Models
[Ultralytics Platform](https://platform.ultralytics.com) provides comprehensive model management for training, analyzing, and deploying YOLO models. Upload pretrained models or train new ones directly on the Platform.
<!-- Screenshot: platform-models-detail.avif -->
## Upload Model
Upload existing model weights to the Platform:
1. Navigate to your project
2. Click **Upload Model**
3. Select your `.pt` file
4. Add name and description
5. Click **Upload**
<!-- Screenshot: platform-models-upload.avif -->
Supported model formats:
| Format | Extension | Description |
| ------- | --------- | ------------------------- |
| PyTorch | `.pt` | Native Ultralytics format |
After upload, the Platform parses model metadata:
- Task type (detect, segment, pose, OBB, classify)
- Architecture (YOLO26n, YOLO26s, etc.)
- Class names and count
- Input size and parameters
## Train Model
Train a new model directly on the Platform:
1. Navigate to your project
2. Click **Train Model**
3. Select dataset
4. Choose base model
5. Configure training parameters
6. Start training
See [Cloud Training](cloud-training.md) for detailed instructions.
## Model Overview
Each model page displays:
| Section | Content |
| ------------ | --------------------------------------- |
| **Overview** | Model metadata, task type, architecture |
| **Metrics** | Training loss and performance charts |
| **Plots** | Confusion matrix, PR curves, F1 curves |
| **Test** | Interactive inference testing |
| **Deploy** | Endpoint creation and management |
| **Export** | Format conversion and download |
## Training Metrics
View real-time and historical training metrics:
### Loss Curves
<!-- Screenshot: platform-models-loss.avif -->
| Loss | Description |
| --------- | ---------------------------- |
| **Box** | Bounding box regression loss |
| **Class** | Classification loss |
| **DFL** | Distribution Focal Loss |
### Performance Metrics
<!-- Screenshot: platform-models-metrics.avif -->
| Metric | Description |
| ------------- | --------------------------------------- |
| **mAP50** | Mean Average Precision at IoU 0.50 |
| **mAP50-95** | Mean Average Precision at IoU 0.50-0.95 |
| **Precision** | Ratio of correct positive predictions |
| **Recall** | Ratio of actual positives identified |
## Validation Plots
After training completes, view detailed validation analysis:
### Confusion Matrix
Interactive heatmap showing prediction accuracy per class:
<!-- Screenshot: platform-models-confusion.avif -->
### PR/F1 Curves
Performance curves at different confidence thresholds:
<!-- Screenshot: platform-models-curves.avif -->
| Curve | Description |
| ------------------------ | ---------------------------------------- |
| **Precision-Recall** | Trade-off between precision and recall |
| **F1-Confidence** | F1 score at different confidence levels |
| **Precision-Confidence** | Precision at different confidence levels |
| **Recall-Confidence** | Recall at different confidence levels |
## Export Model
Export your model to 17 deployment formats:
1. Navigate to the **Export** tab
2. Select target format
3. Click **Export**
4. Download when complete
<!-- Screenshot: platform-models-export.avif -->
### Supported Formats (17 total)
| # | Format | File Extension | Use Case |
| --- | ----------------- | ---------------- | ---------------------------------- |
| 1 | **ONNX** | `.onnx` | Cross-platform, web, most runtimes |
| 2 | **TorchScript** | `.torchscript` | PyTorch deployment without Python |
| 3 | **OpenVINO** | `.xml`, `.bin` | Intel CPUs, GPUs, VPUs |
| 4 | **TensorRT** | `.engine` | NVIDIA GPUs (fastest inference) |
| 5 | **CoreML** | `.mlpackage` | Apple iOS, macOS, watchOS |
| 6 | **TF Lite** | `.tflite` | Mobile (Android, iOS), edge |
| 7 | **TF SavedModel** | `saved_model/` | TensorFlow Serving |
| 8 | **TF GraphDef** | `.pb` | TensorFlow 1.x |
| 9 | **TF Edge TPU** | `.tflite` | Google Coral devices |
| 10 | **TF.js** | `.json`, `.bin` | Browser inference |
| 11 | **PaddlePaddle** | `.pdmodel` | Baidu PaddlePaddle |
| 12 | **NCNN** | `.param`, `.bin` | Mobile (Android/iOS), optimized |
| 13 | **MNN** | `.mnn` | Alibaba mobile runtime |
| 14 | **RKNN** | `.rknn` | Rockchip NPUs |
| 15 | **IMX500** | `.imx` | Sony IMX500 sensor |
| 16 | **Axelera** | `.axelera` | Axelera AI accelerators |
### Format Selection Guide
**For NVIDIA GPUs:** Use **TensorRT** for maximum speed
**For Intel Hardware:** Use **OpenVINO** for Intel CPUs, GPUs, and VPUs
**For Apple Devices:** Use **CoreML** for iOS, macOS, Apple Silicon
**For Android:** Use **TF Lite** or **NCNN** for best performance
**For Web Browsers:** Use **TF.js** or **ONNX** (with ONNX Runtime Web)
**For Edge Devices:** Use **TF Edge TPU** for Coral, **RKNN** for Rockchip
**For General Compatibility:** Use **ONNX** — works with most inference runtimes
<!-- Screenshot: platform-models-export-progress.avif -->
!!! tip "Export Time"
Export time varies by format. TensorRT exports may take several minutes due to engine optimization.
## Dataset Linking
Models can be linked to their source dataset:
- View which dataset was used for training
- Access dataset from model page
- Track data lineage
When training with Platform datasets using the `ul://` URI format, linking is automatic.
## Visibility Settings
Control who can see your model:
| Setting | Description |
| ----------- | ------------------------------- |
| **Private** | Only you can access |
| **Public** | Anyone can view on Explore page |
To change visibility:
1. Open model actions menu
2. Click **Edit**
3. Toggle visibility
4. Click **Save**
## Delete Model
Remove a model you no longer need:
1. Open model actions menu
2. Click **Delete**
3. Confirm deletion
!!! note "Trash and Restore"
Deleted models go to Trash for 30 days. Restore from Settings > Trash.
## FAQ
### What model architectures are supported?
Ultralytics Platform supports all YOLO architectures:
- **YOLO26**: n, s, m, l, x variants (recommended)
- **YOLO11**: n, s, m, l, x variants
- **YOLOv10**: Legacy support
- **YOLOv8**: Legacy support
- **YOLOv5**: Legacy support
### Can I download my trained model?
Yes, download your model weights from the model page:
1. Click the download icon
2. Select format (original `.pt` or exported)
3. Download starts automatically
### How do I compare models across projects?
Currently, model comparison is within projects. To compare across projects:
1. Transfer models to a single project, or
2. Export metrics and compare externally
### What's the maximum model size?
There's no strict limit, but very large models (>2GB) may have longer upload and processing times.
### Can I fine-tune pretrained models?
Yes! Upload a pretrained model, then start training from that checkpoint with your dataset. The Platform automatically uses the uploaded model as the starting point.

132
algorithms/dms_yolo/code/docs/en/platform/train/projects.md Normal file
View File

@@ -0,0 +1,132 @@
---
comments: true
description: Learn how to organize and manage projects in Ultralytics Platform for efficient model development.
keywords: Ultralytics Platform, projects, model management, experiment tracking, YOLO
---
# Projects
[Ultralytics Platform](https://platform.ultralytics.com) projects provide an effective solution for organizing and managing your models. Group related models together to facilitate easier management, comparison, and development.
## Create Project
Navigate to **Projects** in the sidebar and click **Create Project**.
<!-- Screenshot: platform-projects-list.avif -->
??? tip "Quick Create"
You can also create a project from the Home page quick actions.
Enter your project details:
- **Name**: A descriptive name for your project
- **Description**: Optional notes about the project purpose
- **Image**: Optional cover image for recognition
<!-- Screenshot: platform-projects-create.avif -->
Click **Create** to finalize. Your new project appears in the Projects list.
<!-- Screenshot: platform-projects-detail.avif -->
## Project Contents
Each project contains:
| Section | Description |
| ------------ | -------------------------------------------- |
| **Models** | Trained checkpoints and their metrics |
| **Charts** | Compare model performance across experiments |
| **Activity** | History of changes and events |
| **Settings** | Project configuration |
## Edit Project
Update project name, description, or settings:
1. Open project actions menu
2. Click **Edit**
3. Make changes
4. Click **Save**
<!-- Screenshot: platform-projects-settings.avif -->
## Delete Project
Remove a project you no longer need:
1. Open project actions menu
2. Click **Delete**
3. Confirm deletion
!!! warning "Cascading Delete"
Deleting a project also deletes all models inside it. This action moves items to Trash where they can be restored within 30 days.
## Activity Log
Track all changes and events in your project:
- Model uploads and training starts
- Export jobs and downloads
- Settings changes
<!-- Screenshot: platform-projects-activity.avif -->
The activity log helps you:
- Audit who made changes
- Track experiment progress
- Debug issues
## Compare Models
Compare model performance across experiments using the **Charts** tab:
1. Navigate to your project
2. Click the **Charts** tab
3. View metrics comparison across all models
Available comparisons:
| Metric | Description |
| ------------- | --------------------------------------------------- |
| **Loss** | Training and validation loss curves |
| **mAP50** | Mean Average Precision at IoU 0.50 |
| **mAP50-95** | Mean Average Precision at IoU 0.50-0.95 |
| **Precision** | True positives / (True positives + False positives) |
| **Recall** | True positives / (True positives + False negatives) |
!!! tip "Interactive Charts"
- Hover to see exact values
- Click legend items to hide/show models
- Drag to zoom into specific regions
## Transfer Models
Move models between projects:
1. Open model actions menu
2. Click **Transfer**
3. Select destination project
4. Click **Save**
## FAQ
### How many models can a project contain?
There's no hard limit on models per project. However, for better organization, we recommend:
- Group related experiments (same dataset/task)
- Archive old experiments
- Use meaningful project names
### Can I restore a deleted project?
Yes, deleted projects go to Trash and can be restored within 30 days:
1. Go to Settings > Trash
2. Find the project
3. Click **Restore**