torsh-utils 0.1.1

Utility functions and helpers for ToRSh
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

# torsh-utils

Comprehensive utilities and tools for the ToRSh deep learning framework.

## Overview

This crate provides essential utilities for model development, debugging, optimization, and deployment in the ToRSh ecosystem. It includes benchmarking tools, profiling utilities, TensorBoard integration, mobile optimization, and development environment management.

## Features

- **Benchmarking**: Performance analysis and model benchmarking tools
- **Profiling**: Bottleneck detection and performance profiling
- **TensorBoard Integration**: Logging and visualization support
- **Mobile Optimization**: Model optimization for mobile deployment
- **Environment Collection**: Development environment diagnostics
- **C++ Extensions**: Build system for custom C++ operations
- **Model Zoo**: Model repository and management utilities

## Modules

- `benchmark`: Model benchmarking and performance analysis
- `bottleneck`: Performance bottleneck detection and profiling
- `tensorboard`: TensorBoard logging and visualization
- `mobile_optimizer`: Mobile deployment optimization
- `collect_env`: Environment and system information collection
- `cpp_extension`: C++ extension building utilities
- `model_zoo`: Model repository management

## Usage

### Benchmarking

```rust
use torsh_utils::prelude::*;
use torsh_nn::Module;

// Benchmark a model
let config = BenchmarkConfig {
    batch_size: 32,
    warmup_iterations: 10,
    benchmark_iterations: 100,
    measure_memory: true,
    device: DeviceType::Cpu,
};

let result = benchmark_model(&model, &[1, 3, 224, 224], config)?;
println!("Average forward time: {:.2}ms", result.avg_forward_time.as_millis());
```

### Profiling Bottlenecks

```rust
use torsh_utils::prelude::*;

// Profile model bottlenecks
let report = profile_bottlenecks(
    &model,
    &[32, 3, 224, 224], // input shape
    100,                // iterations
    DeviceType::Cpu,
)?;

println!("Bottleneck report:");
for (op, time) in report.operation_times {
    println!("  {}: {:.2}ms", op, time.as_millis());
}
```

### TensorBoard Integration

```rust
use torsh_utils::prelude::*;

// Create TensorBoard writer
let mut writer = SummaryWriter::new("./logs")?;

// Log scalars
writer.add_scalar("train/loss", 0.5, 100)?;
writer.add_scalar("train/accuracy", 0.95, 100)?;

// Log histograms
let weights: Tensor<f32> = model.get_parameter("linear.weight")?;
writer.add_histogram("weights/linear", &weights, 100)?;

writer.close()?;
```

### Mobile Optimization

```rust
use torsh_utils::prelude::*;

// Optimize model for mobile
let config = MobileOptimizerConfig {
    backend: MobileBackend::CoreML,
    export_format: ExportFormat::TorchScript,
    quantize: true,
    quantization_bits: 8,
    optimize_for_inference: true,
    remove_dropout: true,
    fold_batch_norm: true,
};

let optimized_model = optimize_for_mobile(&model, config)?;
```

### Environment Collection

```rust
use torsh_utils::prelude::*;

// Collect environment information
let env_info = collect_env()?;
println!("ToRSh version: {}", env_info.torsh_version);
println!("Rust version: {}", env_info.rust_version);
println!("Available devices: {:?}", env_info.available_devices);
```

## Features

### Default Features
- `std`: Standard library support
- `tensorboard`: TensorBoard integration

### Optional Features
- `profiling`: Advanced profiling capabilities
- `mobile`: Mobile optimization tools
- `cpp-extensions`: C++ extension building

## Dependencies

- `torsh-core`: Core types and device abstraction
- `torsh-tensor`: Tensor operations
- `torsh-nn`: Neural network modules
- `torsh-profiler`: Performance profiling
- `reqwest`: HTTP client for model downloads
- `prometheus`: Metrics collection
- `sysinfo`: System information gathering

## Performance

torsh-utils is optimized for:
- Minimal overhead benchmarking with high-resolution timing
- Efficient memory usage tracking and analysis
- Low-latency profiling with minimal instrumentation impact
- Streaming TensorBoard logging for large-scale training

## Compatibility

Designed to integrate seamlessly with:
- PyTorch TensorBoard logs (compatible format)
- Standard ML development workflows
- CI/CD pipelines for model validation
- Mobile deployment pipelines (iOS/Android)

## Examples

See the `examples/` directory for:
- Comprehensive benchmarking workflows
- Profiling and optimization guides
- TensorBoard integration examples
- Mobile deployment tutorials