Merge pull request #125 from JeroenGar/feat/warm-start

(#124) Warm start

Author: JeroenGar

Cargo.toml

@@ -14,7 +14,7 @@ name = "bench"
 path = "src/bench.rs"
 
 [dependencies]
-jagua-rs = { features = ["spp"], git = "https://github.com/JeroenGar/jagua-rs.git", rev = "b85d9268e46f4273b673325b172caee7b6116583"}
+jagua-rs = { features = ["spp"], git = "https://github.com/JeroenGar/jagua-rs.git", rev = "76aab0fa70688ee50d1809f5376f71c758ea0b7c"}
 #jagua-rs = { features = ["spp"], path = "../jagua-rs/jagua-rs" }
 rand = "0.9"
 rand_distr = "0.5"

README.md

@@ -46,7 +46,7 @@ This repository accompanies the paper: ["_An open-source heuristic to reboot 2D
 **General usage:**
 ```bash
 cargo run --release  -- \
-    -i [path to input JSON] \
+    -i [path to input JSON, or a solution JSON] \
     -t [timelimit in seconds (default is 600s)]
 ```
 The optimization process contains two distinct phases: exploration & compression.
@@ -55,7 +55,7 @@ Pressing 'Ctrl + C' immediately moves the algorithm to the next phase, or termin
 
 **All CLI options:**
 ```bash
--i, --input <INPUT>              Path to the input JSON file
+-i, --input <INPUT>              Path to the input JSON file, or a solution JSON file for warm starting
 -t, --global-time <GLOBAL_TIME>  Set a global time limit (in seconds)
 -e, --exploration <EXPLORATION>  Set the exploration phase time limit (in seconds)
 -c, --compression <COMPRESSION>  Set the compression phase time limit (in seconds)

src/bench.rs

@@ -59,15 +59,15 @@ fn main() -> Result<()> {
     let n_runs_per_iter = (num_cpus::get_physical() / config.expl_cfg.separator_config.n_workers).min(n_runs_total);
     let n_batches = (n_runs_total as f32 / n_runs_per_iter as f32).ceil() as usize;
 
-    let ext_instance = io::read_spp_instance_json(Path::new(&input_file_path))?;
+    let (ext_instance, _) = io::read_spp_input(Path::new(&input_file_path))?;
 
     println!(
         "[BENCH] starting bench for {} ({}x{} runs across {} cores, {:?} timelimit)",
         ext_instance.name, n_batches, n_runs_per_iter, num_cpus::get_physical(), time_limit
     );
 
     let importer = Importer::new(config.cde_config, config.poly_simpl_tolerance, config.min_item_separation, config.narrow_concavity_cutoff_ratio);
-    let instance = jagua_rs::probs::spp::io::import(&importer, &ext_instance)?;
+    let instance = jagua_rs::probs::spp::io::import_instance(&importer, &ext_instance)?;
 
     let mut final_solutions = vec![];
 

src/main.rs

@@ -6,7 +6,7 @@ use rand::SeedableRng;
 use sparrow::config::*;
 use sparrow::optimizer::optimize;
 use sparrow::util::io;
-use sparrow::util::io::{MainCli, SPOutput};
+use sparrow::util::io::{MainCli, ExtSPOutput};
 use std::fs;
 use std::path::Path;
 use std::time::Duration;
@@ -75,10 +75,14 @@ fn main() -> Result<()>{
 
     info!("[MAIN] system time: {}", jiff::Timestamp::now());
 
-    let ext_instance = io::read_spp_instance_json(Path::new(&input_file_path))?;
+    let (ext_instance, ext_solution) = io::read_spp_input(Path::new(&input_file_path))?;
 
     let importer = Importer::new(config.cde_config, config.poly_simpl_tolerance, config.min_item_separation, config.narrow_concavity_cutoff_ratio);
-    let instance = jagua_rs::probs::spp::io::import(&importer, &ext_instance)?;
+    let instance = jagua_rs::probs::spp::io::import_instance(&importer, &ext_instance)?;
+
+    let initial_solution = ext_solution.map(|e|
+        jagua_rs::probs::spp::io::import_solution(&instance, &e)
+    );
 
     info!("[MAIN] loaded instance {} with #{} items", ext_instance.name, instance.total_item_qty());
 
@@ -104,10 +108,18 @@ fn main() -> Result<()>{
 
     let mut ctrlc_terminator = CtrlCTerminator::new();
 
-    let solution = optimize(instance.clone(), rng, &mut svg_exporter, &mut ctrlc_terminator, &config.expl_cfg, &config.cmpr_cfg);
+    let solution = optimize(
+        instance.clone(),
+        rng,
+        &mut svg_exporter,
+        &mut ctrlc_terminator,
+        &config.expl_cfg,
+        &config.cmpr_cfg,
+        initial_solution.as_ref()
+    );
 
     let json_path = format!("{OUTPUT_DIR}/final_{}.json", ext_instance.name);
-    let json_output = SPOutput {
+    let json_output = ExtSPOutput {
         instance: ext_instance,
         solution: jagua_rs::probs::spp::io::export(&instance, &solution, *EPOCH)
     };

src/optimizer/mod.rs

@@ -4,6 +4,7 @@ use crate::optimizer::separator::Separator;
 use jagua_rs::probs::spp::entities::{SPInstance, SPSolution};
 use rand::{RngCore, SeedableRng};
 use std::time::Duration;
+use log::info;
 use rand_xoshiro::Xoshiro256PlusPlus;
 use crate::consts::LBF_SAMPLE_CONFIG;
 use crate::optimizer::compress::compression_phase;
@@ -18,12 +19,31 @@ pub mod explore;
 pub mod compress;
 
 ///Algorithm 11 from https://doi.org/10.48550/arXiv.2509.13329
-pub fn optimize(instance: SPInstance, mut rng: Xoshiro256PlusPlus, sol_listener: &mut impl SolutionListener, terminator: &mut impl Terminator, expl_config: &ExplorationConfig, cmpr_config: &CompressionConfig) -> SPSolution {
+pub fn optimize(
+    instance: SPInstance,
+    mut rng: Xoshiro256PlusPlus,
+    sol_listener: &mut impl SolutionListener,
+    terminator: &mut impl Terminator,
+    expl_config: &ExplorationConfig,
+    cmpr_config: &CompressionConfig,
+    initial_solution: Option<&SPSolution>
+) -> SPSolution {
     let mut next_rng = || Xoshiro256PlusPlus::seed_from_u64(rng.next_u64());
-    let builder = LBFBuilder::new(instance.clone(), next_rng(), LBF_SAMPLE_CONFIG).construct();
+    let start_prob = match initial_solution {
+        None => {
+            let builder = LBFBuilder::new(instance.clone(), next_rng(), LBF_SAMPLE_CONFIG).construct();
+            builder.prob
+        }
+        Some(init_sol) => {
+            info!("[OPT] warm starting from provided initial solution");
+            let mut prob = jagua_rs::probs::spp::entities::SPProblem::new(instance.clone());
+            prob.restore(init_sol);
+            prob
+        }
+    };
 
     terminator.new_timeout(expl_config.time_limit);
-    let mut expl_separator = Separator::new(builder.instance, builder.prob, next_rng(), expl_config.separator_config);
+    let mut expl_separator = Separator::new(instance.clone(), start_prob, next_rng(), expl_config.separator_config);
     let solutions = exploration_phase(
         &instance,
         &mut expl_separator,

src/util/io.rs

@@ -13,7 +13,7 @@ use crate::EPOCH;
 #[derive(Parser)]
 pub struct MainCli {
     /// Path to input file (mandatory)
-    #[arg(short = 'i', long, help = "Path to the input JSON file")]
+    #[arg(short = 'i', long, help = "Path to the input JSON file, or a solution JSON file for warm starting")]
     pub input: String,
 
     /// Global time limit in seconds (mutually exclusive with -e and -c)
@@ -37,7 +37,7 @@ pub struct MainCli {
 }
 
 #[derive(Serialize, Deserialize, Clone)]
-pub struct SPOutput {
+pub struct ExtSPOutput {
     #[serde(flatten)]
     pub instance: ExtSPInstance,
     pub solution: ExtSPSolution,
@@ -111,8 +111,18 @@ pub fn write_json(json: &impl Serialize, path: &Path, log_lvl: Level) -> Result<
     Ok(())
 }
 
-pub fn read_spp_instance_json(path: &Path) -> Result<ExtSPInstance> {
-    let file = File::open(path).context("could not open instance file")?;
-    serde_json::from_reader(BufReader::new(file))
-        .context("not a valid strip packing instance (ExtSPInstance)")
+pub fn read_spp_input(path: &Path) -> Result<(ExtSPInstance, Option<ExtSPSolution>)> {
+    let input_str = fs::read_to_string(path).context("could not read input file")?;
+    //try parsing a full output (instance + solution)
+    match serde_json::from_str::<ExtSPOutput>(&input_str) {
+        Ok(ext_output) => {
+            Ok((ext_output.instance, Some(ext_output.solution)))
+        }
+        Err(_) => {
+            //try parsing just the instance
+            let ext_instance = serde_json::from_str::<ExtSPInstance>(&input_str)
+                .context("could not parse instance from input file")?;
+            Ok((ext_instance, None))
+        }
+    }
 }

tests/tests.rs

@@ -29,10 +29,10 @@ mod integration_tests {
     fn simulate_optimization(path: &str) -> Result<()> {
         let config = DEFAULT_SPARROW_CONFIG;
         let input_file_path = format!("{INSTANCE_BASE_PATH}/{path}");
-        let json_instance = io::read_spp_instance_json(Path::new(&input_file_path))?;
+        let (json_instance, _) = io::read_spp_input(Path::new(&input_file_path))?;
 
         let importer = Importer::new(config.cde_config, config.poly_simpl_tolerance, config.min_item_separation, config.narrow_concavity_cutoff_ratio);
-        let instance = jagua_rs::probs::spp::io::import(&importer, &json_instance)?;
+        let instance = jagua_rs::probs::spp::io::import_instance(&importer, &json_instance)?;
 
         println!("[TEST] loaded instance: {}", json_instance.name);