use crate::error::{BarracudaError, Result};
use crate::ops::interpolation::rbf_kernel::RbfKernelType;
use crate::ops::linalg::{Cholesky, TriangularSolve};
use crate::tensor::Tensor;
pub struct RbfInterpolator {
training_points: Tensor,
weights: Tensor,
kernel: RbfKernelType,
epsilon: f32,
}
impl RbfInterpolator {
pub fn fit(x: &Tensor, y: &Tensor, kernel: RbfKernelType, epsilon: f32) -> Result<Self> {
let x_shape = x.shape();
let y_shape = y.shape();
if x_shape.len() != 2 {
return Err(BarracudaError::InvalidShape {
expected: vec![0, 0],
actual: x_shape.to_vec(),
});
}
if y_shape.len() != 1 {
return Err(BarracudaError::InvalidShape {
expected: vec![x_shape[0]],
actual: y_shape.to_vec(),
});
}
let n = x_shape[0];
if y_shape[0] != n {
return Err(BarracudaError::InvalidShape {
expected: vec![n],
actual: y_shape.to_vec(),
});
}
let k = x.rbf_kernel(x, kernel, epsilon)?;
let l = Cholesky::new(k).execute()?;
let z = TriangularSolve::forward(l.clone(), y.clone()).execute()?;
let l_t = l.transpose()?;
let weights = TriangularSolve::backward(l_t, z).execute()?;
Ok(Self {
training_points: x.clone(),
weights,
kernel,
epsilon,
})
}
pub fn predict(&self, x_new: &Tensor) -> Result<Tensor> {
let x_new_shape = x_new.shape();
let x_train_shape = self.training_points.shape();
if x_new_shape.len() != 2 || x_new_shape[1] != x_train_shape[1] {
return Err(BarracudaError::InvalidShape {
expected: vec![0, x_train_shape[1]],
actual: x_new_shape.to_vec(),
});
}
let k = x_new.rbf_kernel(&self.training_points, self.kernel, self.epsilon)?;
let weights_2d = self.weights.clone().unsqueeze(1)?; let y_pred_2d = k.matmul(&weights_2d)?; let y_pred = y_pred_2d.squeeze()?;
Ok(y_pred)
}
#[must_use]
pub fn training_points(&self) -> &Tensor {
&self.training_points
}
#[must_use]
pub fn weights(&self) -> &Tensor {
&self.weights
}
#[must_use]
pub fn kernel(&self) -> RbfKernelType {
self.kernel
}
#[must_use]
pub fn epsilon(&self) -> f32 {
self.epsilon
}
#[must_use]
pub fn n_training_points(&self) -> usize {
self.training_points.shape()[0]
}
#[must_use]
pub fn input_dimension(&self) -> usize {
self.training_points.shape()[1]
}
}
impl Tensor {
pub fn rbf_interpolate(
&self,
y: &Self,
x_new: &Self,
kernel: RbfKernelType,
epsilon: f32,
) -> Result<Self> {
let rbf = RbfInterpolator::fit(self, y, kernel, epsilon)?;
rbf.predict(x_new)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn test_rbf_interpolator_linear() {
let device = crate::device::test_pool::get_test_device().await;
let x_train_data = vec![1.0, 2.0, 3.0];
let y_expected = vec![2.0, 4.0, 6.0];
let x_train = Tensor::from_vec_on(x_train_data, vec![3, 1], device.clone())
.await
.unwrap();
let y_train = Tensor::from_vec_on(y_expected.clone(), vec![3], device.clone())
.await
.unwrap();
let rbf = RbfInterpolator::fit(&x_train, &y_train, RbfKernelType::Gaussian, 1.0).unwrap();
let y_pred = rbf.predict(&x_train).unwrap();
let predictions = y_pred.to_vec().unwrap();
assert_eq!(predictions.len(), 3);
for (i, (&pred, &expected)) in predictions.iter().zip(y_expected.iter()).enumerate() {
assert!(
(pred - expected).abs() < 0.5,
"Prediction {i} mismatch: expected {expected}, got {pred}"
);
}
}
#[tokio::test]
async fn test_rbf_interpolator_properties() {
let device = crate::device::test_pool::get_test_device().await;
let x_data = vec![0.0, 1.0, 2.0, 3.0, 4.0, 5.0];
let y_data = vec![0.0, 1.0, 4.0, 9.0, 16.0, 25.0];
let x = Tensor::from_vec_on(x_data, vec![6, 1], device.clone())
.await
.unwrap();
let y = Tensor::from_vec_on(y_data, vec![6], device).await.unwrap();
let rbf = RbfInterpolator::fit(&x, &y, RbfKernelType::ThinPlateSpline, 1.0).unwrap();
assert_eq!(rbf.n_training_points(), 6);
assert_eq!(rbf.input_dimension(), 1);
assert_eq!(rbf.kernel(), RbfKernelType::ThinPlateSpline);
assert_eq!(rbf.epsilon(), 1.0);
}
#[tokio::test]
async fn test_rbf_tensor_extension() {
let device = crate::device::test_pool::get_test_device().await;
let x_train_data = vec![1.0, 2.0, 3.0];
let y_train_data = vec![1.0, 2.0, 3.0];
let x_new_data = vec![1.5, 2.5];
let x_train = Tensor::from_vec_on(x_train_data, vec![3, 1], device.clone())
.await
.unwrap();
let y_train = Tensor::from_vec_on(y_train_data, vec![3], device.clone())
.await
.unwrap();
let x_new = Tensor::from_vec_on(x_new_data, vec![2, 1], device)
.await
.unwrap();
let y_pred = x_train
.rbf_interpolate(&y_train, &x_new, RbfKernelType::Cubic, 1.0)
.unwrap();
let predictions = y_pred.to_vec().unwrap();
assert_eq!(predictions.len(), 2);
}
}