use crate::tensor::Tensor;
use mathverse_core::error::{MathError, MathResult};
pub fn mse(pred: &Tensor, target: &Tensor) -> MathResult<f64> {
let n = pred.numel() as f64;
Ok(pred.data.iter().zip(&target.data)
.map(|(p, t)| (p - t).powi(2))
.sum::<f64>() / n)
}
pub fn mse_grad(pred: &Tensor, target: &Tensor) -> MathResult<Tensor> {
let n = pred.numel() as f64;
let data: Vec<f64> = pred.data.iter().zip(&target.data)
.map(|(p, t)| 2.0 * (p - t) / n)
.collect();
Ok(Tensor { shape: pred.shape.clone(), data })
}
pub fn mae(pred: &Tensor, target: &Tensor) -> MathResult<f64> {
let n = pred.numel() as f64;
Ok(pred.data.iter().zip(&target.data)
.map(|(p, t)| (p - t).abs())
.sum::<f64>() / n)
}
pub fn huber(pred: &Tensor, target: &Tensor, delta: f64) -> MathResult<f64> {
let n = pred.numel() as f64;
let sum: f64 = pred.data.iter().zip(&target.data).map(|(p, t)| {
let e = (p - t).abs();
if e <= delta { 0.5 * e * e } else { delta * (e - 0.5 * delta) }
}).sum();
Ok(sum / n)
}
pub fn smooth_l1(pred: &Tensor, target: &Tensor) -> MathResult<f64> {
huber(pred, target, 1.0)
}
pub fn cross_entropy(logits: &Tensor, targets: &Tensor) -> MathResult<f64> {
if logits.shape.len() != 2 {
return Err(MathError::InvalidArgument("cross_entropy requires 2-D logits"));
}
let (batch, classes) = (logits.shape[0], logits.shape[1]);
let n = batch as f64;
let mut loss = 0.0;
for i in 0..batch {
let t = targets.data[i] as usize;
if t >= classes { return Err(MathError::OutOfRange); }
let row = &logits.data[i * classes..(i + 1) * classes];
let max_val = row.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
let lse: f64 = row.iter().map(|&x| (x - max_val).exp()).sum::<f64>().ln() + max_val;
loss += row[t] - lse;
}
Ok(-loss / n)
}
pub fn cross_entropy_grad(logits: &Tensor, targets: &Tensor) -> MathResult<Tensor> {
if logits.shape.len() != 2 {
return Err(MathError::InvalidArgument("cross_entropy requires 2-D logits"));
}
let (batch, classes) = (logits.shape[0], logits.shape[1]);
let n = batch as f64;
let mut grad = vec![0.0; logits.numel()];
for i in 0..batch {
let t = targets.data[i] as usize;
if t >= classes { return Err(MathError::OutOfRange); }
let row = &logits.data[i * classes..(i + 1) * classes];
let max_val = row.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
let exps: Vec<f64> = row.iter().map(|&x| (x - max_val).exp()).collect();
let sum: f64 = exps.iter().sum();
for j in 0..classes {
let sm = exps[j] / sum;
grad[i * classes + j] = if j == t { (sm - 1.0) / n } else { sm / n };
}
}
Ok(Tensor { shape: logits.shape.clone(), data: grad })
}
pub fn binary_cross_entropy(pred: &Tensor, target: &Tensor) -> MathResult<f64> {
let n = pred.numel() as f64;
let eps = 1e-7;
let sum: f64 = pred.data.iter().zip(&target.data).map(|(p, t)| {
let p = p.clamp(eps, 1.0 - eps);
-(t * p.ln() + (1.0 - t) * (1.0 - p).ln())
}).sum();
Ok(sum / n)
}
pub fn binary_cross_entropy_with_logits(logits: &Tensor, target: &Tensor) -> MathResult<f64> {
let n = logits.numel() as f64;
let sum: f64 = logits.data.iter().zip(&target.data).map(|(&l, &t)| {
l.max(0.0) - l * t + (1.0 + (-l.abs()).exp()).ln()
}).sum();
Ok(sum / n)
}
pub fn kl_divergence(p: &Tensor, q: &Tensor) -> MathResult<f64> {
let eps = 1e-10;
let sum: f64 = p.data.iter().zip(&q.data).map(|(p, q)| {
let p = p.max(eps);
let q = q.max(eps);
p * (p / q).ln()
}).sum();
Ok(sum)
}
pub fn hinge_loss(pred: &Tensor, target: &Tensor) -> MathResult<f64> {
let n = pred.numel() as f64;
let sum: f64 = pred.data.iter().zip(&target.data)
.map(|(p, t)| (1.0 - p * t).max(0.0))
.sum();
Ok(sum / n)
}
pub fn cosine_embedding_loss(a: &Tensor, b: &Tensor, target: &Tensor, margin: f64) -> MathResult<f64> {
if a.shape != b.shape { return Err(MathError::DimensionMismatch); }
if a.shape.len() != 2 { return Err(MathError::InvalidArgument("cosine_embedding_loss requires 2-D tensors")); }
let batch = a.shape[0];
let dim = a.shape[1] as f64;
let mut loss = 0.0;
for i in 0..batch {
let a_slice = &a.data[i * dim as usize..(i + 1) * dim as usize];
let b_slice = &b.data[i * dim as usize..(i + 1) * dim as usize];
let dot: f64 = a_slice.iter().zip(b_slice).map(|(x, y)| x * y).sum();
let norm_a: f64 = a_slice.iter().map(|x| x * x).sum::<f64>().sqrt();
let norm_b: f64 = b_slice.iter().map(|x| x * x).sum::<f64>().sqrt();
if norm_a < 1e-10 || norm_b < 1e-10 { continue; }
let cos_sim = dot / (norm_a * norm_b);
let t = target.data[i];
let base = 1.0 - cos_sim;
loss += if t > 0.0 { base.max(0.0) } else { (base - margin).max(0.0) };
}
Ok(loss / batch as f64)
}
#[cfg(test)]
mod tests {
use super::*;
const E: f64 = 1e-6;
#[test]
fn mse_test() {
let pred = Tensor::new(&[3], &[1.0, 2.0, 3.0]).unwrap();
let target = Tensor::new(&[3], &[1.0, 2.0, 5.0]).unwrap();
assert!((mse(&pred, &target).unwrap() - 4.0 / 3.0).abs() < E);
}
#[test]
fn mse_grad_test() {
let pred = Tensor::new(&[3], &[1.0, 2.0, 3.0]).unwrap();
let target = Tensor::new(&[3], &[1.0, 2.0, 5.0]).unwrap();
let g = mse_grad(&pred, &target).unwrap();
assert!((g.data[2] + 4.0 / 3.0).abs() < E); }
#[test]
fn mae_test() {
let pred = Tensor::new(&[3], &[1.0, 2.0, 3.0]).unwrap();
let target = Tensor::new(&[3], &[1.0, 2.0, 5.0]).unwrap();
assert!((mae(&pred, &target).unwrap() - 2.0 / 3.0).abs() < E);
}
#[test]
fn huber_test() {
let pred = Tensor::new(&[2], &[2.0, 0.0]).unwrap();
let target = Tensor::new(&[2], &[0.0, 0.0]).unwrap();
let h = huber(&pred, &target, 1.0).unwrap();
assert!((h - 0.75).abs() < E); }
#[test]
fn cross_entropy_perfect() {
let logits = Tensor::new(&[2, 3], &[10.0, 1.0, 1.0, 1.0, 10.0, 1.0]).unwrap();
let targets = Tensor::new(&[2], &[0.0, 1.0]).unwrap();
let loss = cross_entropy(&logits, &targets).unwrap();
assert!(loss < 0.01); }
#[test]
fn binary_cross_entropy_stable() {
let logits = Tensor::new(&[3], &[10.0, -10.0, 0.0]).unwrap();
let target = Tensor::new(&[3], &[1.0, 0.0, 0.5]).unwrap();
let loss = binary_cross_entropy_with_logits(&logits, &target).unwrap();
assert!(loss >= 0.0);
}
#[test]
fn kl_div_test() {
let p = Tensor::new(&[3], &[0.5, 0.3, 0.2]).unwrap();
let q = Tensor::new(&[3], &[0.5, 0.3, 0.2]).unwrap();
assert!(kl_divergence(&p, &q).unwrap().abs() < E);
}
#[test]
fn hinge_test() {
let pred = Tensor::new(&[3], &[0.8, -0.8, 0.0]).unwrap();
let target = Tensor::new(&[3], &[1.0, -1.0, 1.0]).unwrap();
let h = hinge_loss(&pred, &target).unwrap();
assert!((h - 1.4 / 3.0).abs() < E);
}
}