use super::kernels::RBFKernel;
use super::rbf::{RBFSurrogate, RbfTrainedModel, RbfTrainingData};
use crate::device::WgpuDevice;
use crate::error::{BarracudaError, Result};
use crate::linalg::solve_f64;
use crate::ops::cdist_wgsl::DistanceMetric;
use crate::tensor::Tensor;
use std::sync::Arc;
#[derive(Debug, Clone)]
pub struct AdaptiveConfig {
pub f32_threshold: usize,
pub force_f64: bool,
pub parallel: bool,
pub prefer_gpu: bool,
}
impl Default for AdaptiveConfig {
fn default() -> Self {
Self {
f32_threshold: 200,
force_f64: false,
parallel: true,
prefer_gpu: true,
}
}
}
impl AdaptiveConfig {
#[must_use]
pub fn exact() -> Self {
Self {
force_f64: true,
prefer_gpu: false,
..Default::default()
}
}
#[must_use]
pub fn with_threshold(threshold: usize) -> Self {
Self {
f32_threshold: threshold,
..Default::default()
}
}
#[must_use]
pub fn cpu_only() -> Self {
Self {
prefer_gpu: false,
..Default::default()
}
}
}
#[derive(Debug, Clone)]
pub struct TrainingDiagnostics {
pub used_f32_distances: bool,
pub used_gpu: bool,
pub n_train: usize,
pub n_dim: usize,
pub system_size: usize,
pub max_distance_error: Option<f64>,
}
pub fn train_adaptive(
device: Arc<WgpuDevice>,
x_data: &[Vec<f64>],
y_data: &[f64],
kernel: RBFKernel,
smoothing: f64,
config: &AdaptiveConfig,
) -> Result<(RBFSurrogate, TrainingDiagnostics)> {
let n_train = x_data.len();
if n_train == 0 {
return Err(BarracudaError::InvalidInput {
message: "Training data cannot be empty".to_string(),
});
}
if y_data.len() != n_train {
return Err(BarracudaError::InvalidInput {
message: format!(
"x_data and y_data length mismatch: {} vs {}",
n_train,
y_data.len()
),
});
}
let n_dim = x_data[0].len();
let train_x: Vec<f64> = x_data.iter().flat_map(|row| row.iter().copied()).collect();
let use_f32 = !config.force_f64 && n_train >= config.f32_threshold;
let distances = if use_f32 {
compute_distances_f32_promoted(&train_x, &train_x, n_train, n_train, n_dim)
} else {
compute_distances_f64(&train_x, &train_x, n_train, n_train, n_dim)
};
let surrogate = assemble_and_solve(
device, &train_x, &distances, y_data, kernel, smoothing, n_train, n_dim,
)?;
let diagnostics = TrainingDiagnostics {
used_f32_distances: use_f32,
used_gpu: false,
n_train,
n_dim,
system_size: n_train + n_dim + 1,
max_distance_error: None,
};
Ok((surrogate, diagnostics))
}
pub async fn train_adaptive_gpu(
x_data: &[Vec<f64>],
y_data: &[f64],
kernel: RBFKernel,
smoothing: f64,
device: Arc<WgpuDevice>,
) -> Result<(RBFSurrogate, TrainingDiagnostics)> {
let n_train = x_data.len();
if n_train == 0 {
return Err(BarracudaError::InvalidInput {
message: "Training data cannot be empty".to_string(),
});
}
if y_data.len() != n_train {
return Err(BarracudaError::InvalidInput {
message: format!(
"x_data and y_data length mismatch: {} vs {}",
n_train,
y_data.len()
),
});
}
let n_dim = x_data[0].len();
let train_x_f32: Vec<f32> = x_data
.iter()
.flat_map(|row| row.iter().map(|&v| v as f32))
.collect();
let distances = compute_distances_gpu(&train_x_f32, n_train, n_dim, device.clone()).await?;
let train_x: Vec<f64> = x_data.iter().flat_map(|row| row.iter().copied()).collect();
let surrogate = assemble_and_solve(
device.clone(),
&train_x,
&distances,
y_data,
kernel,
smoothing,
n_train,
n_dim,
)?;
let diagnostics = TrainingDiagnostics {
used_f32_distances: true,
used_gpu: true,
n_train,
n_dim,
system_size: n_train + n_dim + 1,
max_distance_error: None,
};
Ok((surrogate, diagnostics))
}
async fn compute_distances_gpu(
x_f32: &[f32],
n: usize,
n_dim: usize,
device: Arc<WgpuDevice>,
) -> Result<Vec<f64>> {
let tensor = Tensor::from_data(x_f32, vec![n, n_dim], device)?;
let distances_tensor = tensor
.clone()
.cdist_wgsl(tensor, DistanceMetric::Euclidean)?;
let distances_f32 = distances_tensor.to_vec()?;
let distances_f64: Vec<f64> = distances_f32.iter().map(|&v| v as f64).collect();
Ok(distances_f64)
}
pub fn train_with_validation(
device: Arc<WgpuDevice>,
x_data: &[Vec<f64>],
y_data: &[f64],
kernel: RBFKernel,
smoothing: f64,
) -> Result<(RBFSurrogate, TrainingDiagnostics)> {
let n_train = x_data.len();
if n_train == 0 {
return Err(BarracudaError::InvalidInput {
message: "Training data cannot be empty".to_string(),
});
}
if y_data.len() != n_train {
return Err(BarracudaError::InvalidInput {
message: format!(
"x_data and y_data length mismatch: {} vs {}",
n_train,
y_data.len()
),
});
}
let n_dim = x_data[0].len();
let train_x: Vec<f64> = x_data.iter().flat_map(|row| row.iter().copied()).collect();
let distances_f64 = compute_distances_f64(&train_x, &train_x, n_train, n_train, n_dim);
let distances_f32 = compute_distances_f32_promoted(&train_x, &train_x, n_train, n_train, n_dim);
let max_error = distances_f64
.iter()
.zip(distances_f32.iter())
.map(|(a, b)| (a - b).abs())
.fold(0.0_f64, f64::max);
let surrogate = assemble_and_solve(
device,
&train_x,
&distances_f64,
y_data,
kernel,
smoothing,
n_train,
n_dim,
)?;
let diagnostics = TrainingDiagnostics {
used_f32_distances: false,
used_gpu: false,
n_train,
n_dim,
system_size: n_train + n_dim + 1,
max_distance_error: Some(max_error),
};
Ok((surrogate, diagnostics))
}
fn assemble_and_solve(
device: Arc<WgpuDevice>,
train_x: &[f64],
distances: &[f64],
y_data: &[f64],
kernel: RBFKernel,
smoothing: f64,
n_train: usize,
n_dim: usize,
) -> Result<RBFSurrogate> {
let n_poly = n_dim + 1;
let n_total = n_train + n_poly;
let mut a = vec![0.0; n_total * n_total];
let mut b = vec![0.0; n_total];
for i in 0..n_train {
for j in 0..n_train {
let k_ij = kernel.eval(distances[i * n_train + j]);
let smooth = if i == j { smoothing } else { 0.0 };
a[i * n_total + j] = k_ij + smooth;
}
}
for i in 0..n_train {
a[i * n_total + n_train] = 1.0;
a[n_train * n_total + i] = 1.0;
for d in 0..n_dim {
a[i * n_total + (n_train + 1 + d)] = train_x[i * n_dim + d];
a[(n_train + 1 + d) * n_total + i] = train_x[i * n_dim + d];
}
}
b[..n_train].copy_from_slice(y_data);
let mut weights = solve_f64(device.clone(), &a, &b, n_total)?;
let poly_coeffs = weights.split_off(n_train);
Ok(RBFSurrogate::from_parts(
device,
RbfTrainingData {
train_x: train_x.to_vec(),
train_y: y_data.to_vec(),
n_train,
n_dim,
},
RbfTrainedModel {
weights,
poly_coeffs,
kernel,
smoothing,
},
))
}
fn compute_distances_f64(x1: &[f64], x2: &[f64], n1: usize, n2: usize, n_dim: usize) -> Vec<f64> {
let mut distances = vec![0.0; n1 * n2];
for i in 0..n1 {
for j in 0..n2 {
let mut dist_sq = 0.0;
for d in 0..n_dim {
let diff = x1[i * n_dim + d] - x2[j * n_dim + d];
dist_sq = diff.mul_add(diff, dist_sq);
}
distances[i * n2 + j] = dist_sq.sqrt();
}
}
distances
}
fn compute_distances_f32_promoted(
x1: &[f64],
x2: &[f64],
n1: usize,
n2: usize,
n_dim: usize,
) -> Vec<f64> {
let x1_f32: Vec<f32> = x1.iter().map(|&v| v as f32).collect();
let x2_f32: Vec<f32> = x2.iter().map(|&v| v as f32).collect();
let mut distances = vec![0.0f64; n1 * n2];
for i in 0..n1 {
for j in 0..n2 {
let mut dist_sq = 0.0f32;
for d in 0..n_dim {
let diff = x1_f32[i * n_dim + d] - x2_f32[j * n_dim + d];
dist_sq = diff.mul_add(diff, dist_sq);
}
distances[i * n2 + j] = (dist_sq.sqrt()) as f64;
}
}
distances
}
#[cfg(test)]
mod tests;