use crate::tensor::Tensor;
use mathverse_core::error::{MathError, MathResult};
pub fn vae_reparameterize(mean: &Tensor, logvar: &Tensor) -> MathResult<Tensor> {
if mean.shape != logvar.shape {
return Err(MathError::DimensionMismatch);
}
let std = logvar.mul_scalar(0.5).exp();
let eps = Tensor::randn(&mean.shape);
mean.add(&std.mul(&eps)?)
}
pub fn vae_loss(
recon: &Tensor,
original: &Tensor,
mean: &Tensor,
logvar: &Tensor,
) -> MathResult<f64> {
if recon.shape != original.shape || mean.shape != logvar.shape {
return Err(MathError::DimensionMismatch);
}
let diff = recon.sub(original)?;
let recon_loss = diff.data.iter().map(|x| x * x).sum::<f64>() / diff.numel() as f64;
let kl: f64 = mean.data.iter().zip(&logvar.data)
.map(|(m, lv)| -0.5 * (1.0 + lv - m * m - lv.exp()))
.sum();
Ok(recon_loss + kl)
}
pub fn gan_discriminator_loss(real_pred: &Tensor, fake_pred: &Tensor) -> MathResult<f64> {
let eps = 1e-12;
let real_loss: f64 = real_pred.data.iter()
.map(|&x| -(x.max(eps).ln()))
.sum::<f64>() / real_pred.numel() as f64;
let fake_loss: f64 = fake_pred.data.iter()
.map(|&x| -((1.0 - x).max(eps).ln()))
.sum::<f64>() / fake_pred.numel() as f64;
Ok(real_loss + fake_loss)
}
pub fn gan_generator_loss(fake_pred: &Tensor) -> MathResult<f64> {
let eps = 1e-12;
let loss: f64 = fake_pred.data.iter()
.map(|&x| -(x.max(eps).ln()))
.sum::<f64>() / fake_pred.numel() as f64;
Ok(loss)
}
pub fn diffusion_forward_process(
x0: &Tensor,
t: usize,
betas: &[f64],
) -> MathResult<(Tensor, Tensor)> {
if t >= betas.len() {
return Err(MathError::InvalidArgument("t must be < betas.len()"));
}
let mut alpha_bar = 1.0;
#[allow(clippy::needless_range_loop)]
for i in 0..=t {
alpha_bar *= 1.0 - betas[i];
}
let sqrt_alpha = alpha_bar.sqrt();
let sqrt_one_minus_alpha = (1.0 - alpha_bar).sqrt();
let noise = Tensor::randn(&x0.shape);
let noisy = x0.mul_scalar(sqrt_alpha).add(&noise.mul_scalar(sqrt_one_minus_alpha))?;
Ok((noisy, noise))
}
pub fn diffusion_reverse_process(
x_t: &Tensor,
predicted_noise: &Tensor,
t: usize,
betas: &[f64],
) -> MathResult<Tensor> {
if t >= betas.len() {
return Err(MathError::InvalidArgument("t must be < betas.len()"));
}
let beta_t = betas[t];
let alpha_t = 1.0 - beta_t;
let mut alpha_bar = 1.0;
#[allow(clippy::needless_range_loop)]
for i in 0..=t {
alpha_bar *= 1.0 - betas[i];
}
let sqrt_alpha = alpha_t.sqrt();
let coeff = beta_t / (1.0 - alpha_bar).sqrt();
let mean = x_t.sub(&predicted_noise.mul_scalar(coeff))?.div_scalar(sqrt_alpha);
let sigma = beta_t.sqrt();
let z = Tensor::randn(&x_t.shape);
mean.add(&z.mul_scalar(sigma))
}
#[cfg(test)]
mod tests {
use super::*;
const E: f64 = 1e-4;
#[test]
fn vae_reparameterize_test() {
let mean = Tensor::new(&[2, 3], &[0.0; 6]).unwrap();
let logvar = Tensor::new(&[2, 3], &[0.0; 6]).unwrap();
let z = vae_reparameterize(&mean, &logvar).unwrap();
assert_eq!(z.shape, vec![2, 3]);
assert!(z.data.iter().all(|&x| x.is_finite()));
}
#[test]
fn vae_loss_test() {
let recon = Tensor::new(&[2], &[0.5, 0.5]).unwrap();
let original = Tensor::new(&[2], &[1.0, 1.0]).unwrap();
let mean = Tensor::new(&[2], &[0.0, 0.0]).unwrap();
let logvar = Tensor::new(&[2], &[0.0, 0.0]).unwrap();
let loss = vae_loss(&recon, &original, &mean, &logvar).unwrap();
assert!((loss - 0.25).abs() < E);
}
#[test]
fn gan_discriminator_loss_test() {
let real_pred = Tensor::new(&[4], &[0.9, 0.8, 0.85, 0.95]).unwrap();
let fake_pred = Tensor::new(&[4], &[0.1, 0.2, 0.15, 0.05]).unwrap();
let loss = gan_discriminator_loss(&real_pred, &fake_pred).unwrap();
assert!(loss > 0.0);
assert!(loss.is_finite());
}
#[test]
fn gan_generator_loss_test() {
let fake_pred = Tensor::new(&[4], &[0.9, 0.8, 0.85, 0.95]).unwrap();
let loss = gan_generator_loss(&fake_pred).unwrap();
assert!(loss > 0.0);
assert!(loss.is_finite());
let fake_bad = Tensor::new(&[4], &[0.1, 0.1, 0.1, 0.1]).unwrap();
let loss_bad = gan_generator_loss(&fake_bad).unwrap();
assert!(loss_bad > loss);
}
#[test]
fn diffusion_forward_test() {
let x0 = Tensor::new(&[1, 4], &[1.0, 2.0, 3.0, 4.0]).unwrap();
let betas: Vec<f64> = (0..10).map(|i| 0.001 + i as f64 * 0.0001).collect();
let (noisy, noise) = diffusion_forward_process(&x0, 5, &betas).unwrap();
assert_eq!(noisy.shape, vec![1, 4]);
assert_eq!(noise.shape, vec![1, 4]);
let diff: f64 = noisy.data.iter().zip(&x0.data).map(|(a, b)| (a - b).abs()).sum::<f64>() / 4.0;
assert!(diff > 1e-6);
}
#[test]
fn diffusion_reverse_test() {
let x_t = Tensor::new(&[1, 4], &[0.5, 1.5, 2.5, 3.5]).unwrap();
let noise = Tensor::new(&[1, 4], &[0.1, 0.1, 0.1, 0.1]).unwrap();
let betas: Vec<f64> = (0..10).map(|i| 0.001 + i as f64 * 0.0001).collect();
let x_prev = diffusion_reverse_process(&x_t, &noise, 5, &betas).unwrap();
assert_eq!(x_prev.shape, vec![1, 4]);
assert!(x_prev.data.iter().all(|&x| x.is_finite()));
}
}