use std::panic::{AssertUnwindSafe, catch_unwind, resume_unwind};
use serde::{Deserialize, Serialize};
use crate::{
Device, DeviceSpec, Result, RustTorchError, Tensor, no_grad, optim::Optimizer, resolve_device,
};
pub fn autocast<T>(enabled: bool, operation: impl FnOnce() -> T) -> T {
match tch::autocast(enabled, || catch_unwind(AssertUnwindSafe(operation))) {
Ok(value) => value,
Err(panic) => resume_unwind(panic),
}
}
pub fn autocast_for<T>(
device: Device,
enabled: bool,
operation: impl FnOnce() -> Result<T>,
) -> Result<T> {
if enabled {
match device {
Device::Cuda(index) => {
resolve_device(DeviceSpec::Cuda(index))?;
}
_ => {
return Err(invalid(
"autocast device",
"the linked safe API supports CUDA autocast only",
));
}
}
}
autocast(enabled, operation)
}
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GradScalerConfig {
pub initial_scale: f64,
pub growth_factor: f64,
pub backoff_factor: f64,
pub growth_interval: u64,
pub enabled: bool,
}
impl Default for GradScalerConfig {
fn default() -> Self {
Self {
initial_scale: 65536.0,
growth_factor: 2.0,
backoff_factor: 0.5,
growth_interval: 2000,
enabled: true,
}
}
}
impl GradScalerConfig {
pub fn build(self) -> Result<GradScaler> {
self.validate()?;
Ok(GradScaler {
config: self,
scale: if self.enabled {
(self.initial_scale as f32) as f64
} else {
1.0
},
growth_tracker: 0,
phase: Phase::Ready,
})
}
fn validate(self) -> Result<()> {
validate_scale(self.initial_scale)?;
if !self.growth_factor.is_finite() || self.growth_factor <= 1.0 {
return Err(invalid(
"growth_factor",
"must be finite and greater than one",
));
}
if !self.backoff_factor.is_finite()
|| !(0.0..1.0).contains(&self.backoff_factor)
|| self.backoff_factor == 0.0
{
return Err(invalid(
"backoff_factor",
"must be finite and strictly between zero and one",
));
}
if self.growth_interval == 0 {
return Err(invalid("growth_interval", "must be positive"));
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GradScalerState {
pub schema_version: u32,
pub config: GradScalerConfig,
pub scale: f64,
pub growth_tracker: u64,
}
#[derive(Debug)]
enum Phase {
Ready,
Unscaled { optimizer: u64, finite: bool },
Stepped { applied: bool },
}
#[derive(Debug)]
pub struct GradScaler {
config: GradScalerConfig,
scale: f64,
growth_tracker: u64,
phase: Phase,
}
impl Default for GradScaler {
fn default() -> Self {
GradScalerConfig::default()
.build()
.expect("valid default scaler policy")
}
}
impl GradScaler {
pub const fn get_scale(&self) -> f64 {
self.scale
}
pub const fn is_enabled(&self) -> bool {
self.config.enabled
}
pub fn scale(&self, loss: &Tensor) -> Result<Tensor> {
self.require_ready()?;
if !loss.defined() || !loss.size().is_empty() {
return Err(invalid("loss", "scaling requires a defined scalar loss"));
}
loss.f_mul_scalar(self.scale).map_err(Into::into)
}
pub fn unscale(&mut self, optimizer: &Optimizer) -> Result<()> {
self.require_ready()?;
let gradients: Vec<_> = optimizer
.trainable_variables()
.iter()
.map(Tensor::grad)
.filter(Tensor::defined)
.collect();
if gradients.is_empty() {
return Err(invalid(
"gradients",
"no gradients were produced for this optimizer",
));
}
if gradients.iter().any(Tensor::is_sparse) {
return Err(invalid(
"gradients",
"gradient scaling currently requires dense gradients",
));
}
let mut finite = true;
let mut staged = Vec::with_capacity(gradients.len());
for gradient in gradients {
let unscaled = gradient.f_div_scalar(self.scale)?;
if self.config.enabled && unscaled.f_isfinite()?.f_all()?.f_int64_value(&[])? == 0 {
finite = false;
}
staged.push((gradient, unscaled));
}
no_grad(|| -> Result<()> {
for (mut gradient, unscaled) in staged {
gradient.f_copy_(&unscaled)?;
}
Ok(())
})?;
self.phase = Phase::Unscaled {
optimizer: optimizer.identity(),
finite,
};
Ok(())
}
pub fn step(&mut self, optimizer: &mut Optimizer) -> Result<bool> {
if matches!(self.phase, Phase::Ready) {
self.unscale(optimizer)?;
}
let Phase::Unscaled {
optimizer: identity,
finite,
} = self.phase
else {
return Err(invalid(
"scaler phase",
"step already completed; call update before the next step",
));
};
if identity != optimizer.identity() {
return Err(invalid(
"optimizer",
"must match the optimizer whose gradients were unscaled",
));
}
if finite {
optimizer.try_step()?;
}
self.phase = Phase::Stepped { applied: finite };
Ok(finite)
}
pub fn update(&mut self) -> Result<()> {
let Phase::Stepped { applied } = self.phase else {
return Err(invalid("scaler phase", "update requires a completed step"));
};
if self.config.enabled {
if applied {
self.growth_tracker += 1;
if self.growth_tracker == self.config.growth_interval {
let next = (self.scale * self.config.growth_factor) as f32;
if next.is_finite() {
self.scale = next as f64;
}
self.growth_tracker = 0;
}
} else {
self.scale = ((self.scale * self.config.backoff_factor) as f32)
.max(f32::MIN_POSITIVE) as f64;
self.growth_tracker = 0;
}
}
self.phase = Phase::Ready;
Ok(())
}
pub fn state_dict(&self) -> Result<GradScalerState> {
self.require_ready()?;
Ok(GradScalerState {
schema_version: 1,
config: self.config,
scale: self.scale,
growth_tracker: self.growth_tracker,
})
}
pub fn load_state_dict(&mut self, state: &GradScalerState) -> Result<()> {
self.require_ready()?;
if state.schema_version != 1 {
return Err(invalid("scaler state", "unsupported schema version"));
}
state.config.validate()?;
validate_scale(state.scale)?;
if state.growth_tracker >= state.config.growth_interval
|| (!state.config.enabled && (state.scale != 1.0 || state.growth_tracker != 0))
{
return Err(invalid(
"scaler state",
"invalid growth tracker or disabled scale",
));
}
self.config = state.config;
self.scale = (state.scale as f32) as f64;
self.growth_tracker = state.growth_tracker;
Ok(())
}
fn require_ready(&self) -> Result<()> {
if matches!(self.phase, Phase::Ready) {
Ok(())
} else {
Err(invalid(
"scaler phase",
"finish step and update before starting another cycle",
))
}
}
}
fn validate_scale(value: f64) -> Result<()> {
if !value.is_finite() || value < f32::MIN_POSITIVE as f64 || value > f32::MAX as f64 {
return Err(invalid(
"scale",
"must be within positive finite normal f32 magnitudes",
));
}
Ok(())
}
fn invalid(field: &'static str, reason: &str) -> RustTorchError {
RustTorchError::InvalidConfiguration {
field,
reason: reason.into(),
}
}