use std::path::Path;
use std::sync::Arc;
use burn::config::Config;
use burn::tensor::backend::AutodiffBackend;
use rand::seq::SliceRandom;
use crate::destroy::DestroyOperator;
use crate::learning::consformer::{ConsFormerLoss, DecomposedMddLoss};
use crate::learning::{TrainingConfig, train_model};
use crate::mdd::MddCompilationConfig;
use crate::modelling::Problem;
use crate::neural::consformer::{
ConsFormerBatch, ConsFormerBatcher, ConsFormerConfig, ConsFormerDataset, ConsFormerSample,
};
use crate::neural::dispatch_backend;
use crate::utils::with_rng;
type ProblemSplit = (Vec<Arc<Problem>>, Vec<Arc<Problem>>, Vec<Arc<Problem>>);
fn split_train_validation(
mut problems: Vec<Arc<Problem>>,
validation: Option<Vec<Arc<Problem>>>,
) -> ProblemSplit {
if let Some(validation_problems) = validation {
let mut all_problems = problems.clone();
all_problems.extend(validation_problems.iter().cloned());
return (all_problems, problems, validation_problems);
}
let all_problems = problems.clone();
let training_size = (problems.len() as f64 * 0.8).round() as usize;
with_rng(|rng| problems.shuffle(rng));
let validation_problems = problems.split_off(training_size);
(all_problems, problems, validation_problems)
}
fn prepare_checkpoint_dir(
checkpoint_dir: &Path,
network_config: &ConsFormerConfig,
) -> Result<(), String> {
std::fs::create_dir_all(checkpoint_dir).map_err(|e| {
format!(
"failed to create the checkpoint directory {}: {e}",
checkpoint_dir.display()
)
})?;
network_config
.save(checkpoint_dir.join("config.json"))
.map_err(|e| format!("failed to save the network configuration: {e}"))
}
pub fn train_consformer(
problems: Vec<Arc<Problem>>,
validation: Option<Vec<Arc<Problem>>>,
network_config: ConsFormerConfig,
training_config: TrainingConfig,
destroy: Option<Arc<dyn DestroyOperator>>,
checkpoint_dir: &Path,
) -> Result<(), String> {
dispatch_backend!(
training,
train_consformer_on,
problems,
validation,
network_config,
training_config,
destroy,
checkpoint_dir,
)
}
pub fn train_consformer_on<B: AutodiffBackend>(
device: B::Device,
problems: Vec<Arc<Problem>>,
validation: Option<Vec<Arc<Problem>>>,
network_config: ConsFormerConfig,
training_config: TrainingConfig,
destroy: Option<Arc<dyn DestroyOperator>>,
checkpoint_dir: &Path,
) -> Result<(), String> {
prepare_checkpoint_dir(checkpoint_dir, &network_config)?;
let (all_problems, problems, validation_problems) =
split_train_validation(problems, validation);
let train_dataset = ConsFormerDataset::<B>::new(problems, &device);
let validation_dataset =
ConsFormerDataset::<B::InnerBackend>::new(validation_problems, &device);
let batcher = ConsFormerBatcher {
mask_fraction: network_config.mask_fraction,
destroy,
};
train_model::<
B,
ConsFormerConfig,
ConsFormerSample<B>,
ConsFormerBatch<B>,
ConsFormerBatcher,
ConsFormerLoss,
ConsFormerSample<B::InnerBackend>,
ConsFormerBatch<B::InnerBackend>,
>(
network_config,
&all_problems,
train_dataset,
validation_dataset,
batcher,
ConsFormerLoss,
training_config,
checkpoint_dir,
&device,
)
.map(|_| ())
}
pub fn train_consformer_mdd(
problems: Vec<Arc<Problem>>,
validation: Option<Vec<Arc<Problem>>>,
network_config: ConsFormerConfig,
training_config: TrainingConfig,
compilation: MddCompilationConfig,
checkpoint_dir: &Path,
) -> Result<(), String> {
dispatch_backend!(
training,
train_consformer_mdd_on,
problems,
validation,
network_config,
training_config,
compilation,
checkpoint_dir,
)
}
pub fn train_consformer_mdd_on<B: AutodiffBackend>(
device: B::Device,
problems: Vec<Arc<Problem>>,
validation: Option<Vec<Arc<Problem>>>,
network_config: ConsFormerConfig,
training_config: TrainingConfig,
compilation: MddCompilationConfig,
checkpoint_dir: &Path,
) -> Result<(), String> {
prepare_checkpoint_dir(checkpoint_dir, &network_config)?;
let (all_problems, problems, validation_problems) =
split_train_validation(problems, validation);
let loss = DecomposedMddLoss::new(compilation, network_config.domain_size);
let train_dataset = ConsFormerDataset::<B>::new(problems, &device);
let validation_dataset =
ConsFormerDataset::<B::InnerBackend>::new(validation_problems, &device);
let batcher = ConsFormerBatcher {
mask_fraction: network_config.mask_fraction,
destroy: None,
};
train_model::<
B,
ConsFormerConfig,
ConsFormerSample<B>,
ConsFormerBatch<B>,
ConsFormerBatcher,
DecomposedMddLoss,
ConsFormerSample<B::InnerBackend>,
ConsFormerBatch<B::InnerBackend>,
>(
network_config,
&all_problems,
train_dataset,
validation_dataset,
batcher,
loss,
training_config,
checkpoint_dir,
&device,
)
.map(|_| ())
}