#![deny(missing_docs)]
#![warn(clippy::missing_docs_in_private_items)]
pub mod consformer;
use std::path::Path;
use std::sync::Arc;
use burn::config::Config;
use burn::module::Module;
use burn::record::CompactRecorder;
use burn::tensor::backend::{AutodiffBackend, Backend};
use burn::tensor::{Bool, Int, Tensor};
use crate::modelling::Problem;
pub fn cuda_available() -> bool {
use burn::backend::cuda::{Cuda, CudaDevice};
let prev_hook = std::panic::take_hook();
std::panic::set_hook(Box::new(|_| {}));
let result = std::panic::catch_unwind(|| {
let device = CudaDevice::default();
let tensor = burn::tensor::Tensor::<Cuda, 1>::from_data([0.0f32], &device);
let _ = tensor.into_data();
});
std::panic::set_hook(prev_hook);
result.is_ok()
}
pub fn seed_backends(seed: u64) {
use burn::backend::cuda::{Cuda, CudaDevice};
use burn::backend::ndarray::{NdArray, NdArrayDevice};
NdArray::<f32>::seed(&NdArrayDevice::default(), seed);
if cuda_available() {
Cuda::<f32>::seed(&CudaDevice::default(), seed);
}
}
macro_rules! dispatch_backend {
(training, $call:ident, $($args:expr),* $(,)?) => {
if $crate::neural::cuda_available() {
$call::<burn::backend::Autodiff<burn::backend::cuda::Cuda>>(
burn::backend::cuda::CudaDevice::default(), $($args),*)
} else {
$call::<burn::backend::Autodiff<burn::backend::ndarray::NdArray>>(
burn::backend::ndarray::NdArrayDevice::default(), $($args),*)
}
};
(inference, $call:ident, $($args:expr),* $(,)?) => {
if $crate::neural::cuda_available() {
$call::<burn::backend::cuda::Cuda>(burn::backend::cuda::CudaDevice::default(), $($args),*)
} else {
$call::<burn::backend::ndarray::NdArray>(
burn::backend::ndarray::NdArrayDevice::default(), $($args),*)
}
};
}
pub(crate) use dispatch_backend;
pub trait InferenceJob {
type Output;
fn run<B: Backend>(self, device: B::Device) -> Self::Output;
}
pub trait TrainingJob {
type Output;
fn run<B: AutodiffBackend>(self, device: B::Device) -> Self::Output;
}
pub fn run_inference<J: InferenceJob>(job: J) -> J::Output {
use burn::backend::cuda::{Cuda, CudaDevice};
use burn::backend::ndarray::{NdArray, NdArrayDevice};
if cuda_available() {
job.run::<Cuda>(CudaDevice::default())
} else {
job.run::<NdArray>(NdArrayDevice::default())
}
}
pub fn run_training<J: TrainingJob>(job: J) -> J::Output {
use burn::backend::Autodiff;
use burn::backend::cuda::{Cuda, CudaDevice};
use burn::backend::ndarray::{NdArray, NdArrayDevice};
if cuda_available() {
job.run::<Autodiff<Cuda>>(CudaDevice::default())
} else {
job.run::<Autodiff<NdArray>>(NdArrayDevice::default())
}
}
pub trait Batch<B: Backend>: Clone + Send + Sync + std::fmt::Debug + 'static {
fn problems(&self) -> &[Arc<Problem>];
fn assignments(&self) -> Tensor<B, 2, Int>;
fn var_masks(&self) -> Tensor<B, 2, Bool>;
fn decode(&self, logits: Tensor<B, 3>) -> Vec<Vec<isize>>;
fn check_problems(problems: &[Arc<Problem>]) -> Result<(), String>;
fn for_assignments(
problems: &[Arc<Problem>],
assignments: Tensor<B, 2, Int>,
destroy_mask: Tensor<B, 2, Int>,
device: &B::Device,
) -> Self;
}
pub trait Network<B: Backend, Ba: Batch<B>>: Module<B> {
fn forward(&self, batch: &Ba) -> Tensor<B, 3>;
}
pub trait NetworkConfig<B: Backend> {
type N: Module<B>;
fn init(&self, problems: &[Arc<Problem>], device: &B::Device) -> Self::N;
}
pub fn load_network<B, NC>(
checkpoint_dir: &Path,
problems: &[Arc<Problem>],
device: &B::Device,
) -> Result<(NC, NC::N), Box<dyn std::error::Error>>
where
B: Backend,
NC: NetworkConfig<B> + Config + Clone,
NC::N: Module<B>,
{
let config: NC = NC::load(checkpoint_dir.join("config.json"))?;
let network = config.clone().init(problems, device).load_file(
checkpoint_dir.join("weights"),
&CompactRecorder::new(),
device,
)?;
Ok((config, network))
}