Download loda-rust/rust_project/loda-rust-cli/src/subcommand_export_dataset.rs from Alignment-Lab-AI/ARC-stuff: direct link, hf CLI and curl.
- Browser
- Download file 8.23 kB
-
https://huggingface.co/datasets/Alignment-Lab-AI/ARC-stuff/resolve/main/loda-rust/rust_project/loda-rust-cli/src/subcommand_export_dataset.rs
- Command line
-
hf download hf://datasets/Alignment-Lab-AI/ARC-stuff/loda-rust/rust_project/loda-rust-cli/src/subcommand_export_dataset.rs
-
curl -L -o subcommand_export_dataset.rs https://huggingface.co/datasets/Alignment-Lab-AI/ARC-stuff/resolve/main/loda-rust/rust_project/loda-rust-cli/src/subcommand_export_dataset.rs
8.23 kB
| //! The `loda-rust export-dataset` subcommand, exports terms and programs to a CSV file. | |
| use crate::analytics::{Analytics, AnalyticsDirectory}; | |
| use crate::config::Config; | |
| use crate::common::{find_asm_files_recursively, load_program_ids_csv_file, oeis_id_from_path}; | |
| use crate::common::create_csv_file; | |
| use crate::oeis::{ProcessStrippedFile, StrippedRow}; | |
| use anyhow::Context; | |
| use loda_rust_core::util::BigIntVecToString; | |
| use loda_rust_core::oeis::OeisIdHashSet; | |
| use loda_rust_core::oeis::OeisId; | |
| use loda_rust_core::parser::{ParsedProgram}; | |
| use std::collections::{HashMap, HashSet}; | |
| use std::fs; | |
| use std::fs::File; | |
| use std::io::BufReader; | |
| use std::path::{Path, PathBuf}; | |
| use std::time::Instant; | |
| use console::Style; | |
| use indicatif::{HumanDuration, ProgressBar}; | |
| use serde::Serialize; | |
| use num_bigint::BigInt; | |
| use num_traits::Zero; | |
| /// In the OEIS stripped file. Ignore sequences that too short. | |
| const MIN_TERM_COUNT: usize = 20; | |
| /// In the OEIS stripped file. Only extract up to this number of terms. | |
| const MAX_TERM_COUNT: usize = 20; | |
| pub type OeisIdToTermsSet = HashMap::<OeisId, String>; | |
| /// This outputs a CSV file. | |
| /// | |
| /// Path to the generated file: `~/.loda-rust/analytics/dataset.csv`. | |
| /// | |
| /// Sample data: | |
| /// | |
| /// ```csv | |
| /// oeis;terms;loda | |
| /// 1950;2,5,7,10,13,15,18,20,23,26,28,31,34,36,39,41,44,47,49,52;mov $1,$0\nadd $0,1\nseq $0,99267\nsub $0,1\nadd $0,$1 | |
| /// 1951;0,1,2,4,5,7,8,9,11,12,14,15,16,18,19,21,22,24,25,26;mov $1,$0\nmul $1,$0\nlpb $1\nsub $1,$0\nadd $0,1\nsub $1,$0\nlpe | |
| /// 1952;3,6,10,13,17,20,23,27,30,34,37,40,44,47,51,54,58,61,64,68;seq $0,286927\ndiv $0,2 | |
| /// 1953;0,2,3,4,6,7,9,10,12,13,14,16,17,19,20,21,23,24,26,27;mov $1,$0\nmul $0,2\npow $1,2\nlpb $1\nsub $1,1\nadd $0,2\ntrn $1,$0\nlpe\ndiv $0,2 | |
| /// ``` | |
| pub struct SubcommandExportDataset { | |
| analytics_directory: AnalyticsDirectory, | |
| config: Config, | |
| count_ignored: usize, | |
| count_insufficient_number_of_terms: usize, | |
| oeis_id_to_terms_set: OeisIdToTermsSet, | |
| records: Vec<Record>, | |
| } | |
| impl SubcommandExportDataset { | |
| pub fn export_dataset() -> anyhow::Result<()> { | |
| let config = Config::load(); | |
| let analytics_directory = AnalyticsDirectory::new( | |
| config.analytics_oeis_dir() | |
| ).with_context(||"unable to create AnalyticsDirectory instance")?; | |
| let mut instance = Self { | |
| analytics_directory, | |
| config, | |
| count_ignored: 0, | |
| count_insufficient_number_of_terms: 0, | |
| records: vec!(), | |
| oeis_id_to_terms_set: OeisIdToTermsSet::new(), | |
| }; | |
| instance.run()?; | |
| Ok(()) | |
| } | |
| fn run(&mut self) -> anyhow::Result<()> { | |
| Analytics::oeis_run_if_expired()?; | |
| self.load_stripped_file()?; | |
| self.process_program_files()?; | |
| self.save()?; | |
| println!("Ok"); | |
| Ok(()) | |
| } | |
| fn load_stripped_file(&mut self) -> anyhow::Result<()> { | |
| let mut oeis_id_to_terms_set = OeisIdToTermsSet::new(); | |
| let callback = |row: &StrippedRow, _| { | |
| let value: String = row.terms().to_compact_comma_string(); | |
| let key: OeisId = row.oeis_id(); | |
| oeis_id_to_terms_set.insert(key, value); | |
| }; | |
| let oeis_stripped_file = self.config.oeis_stripped_file(); | |
| let file = File::open(oeis_stripped_file)?; | |
| let mut oeis_stripped_file_reader = BufReader::new(file); | |
| let padding_value = BigInt::zero(); | |
| let mut processor = ProcessStrippedFile::new(); | |
| let oeis_ids_to_ignore = OeisIdHashSet::new(); | |
| processor.execute( | |
| &mut oeis_stripped_file_reader, | |
| MIN_TERM_COUNT, | |
| MAX_TERM_COUNT, | |
| &oeis_ids_to_ignore, | |
| &padding_value, | |
| false, | |
| callback | |
| ); | |
| self.oeis_id_to_terms_set = oeis_id_to_terms_set; | |
| Ok(()) | |
| } | |
| fn process_program_files(&mut self) -> anyhow::Result<()> { | |
| let programs_invalid_file = self.analytics_directory.programs_invalid_file(); | |
| let invalid_program_ids: Vec<u32> = match load_program_ids_csv_file(&programs_invalid_file) { | |
| Ok(value) => value, | |
| Err(error) => { | |
| return Err(anyhow::anyhow!("Unable to load csv file with invalid programs. {:?}", error)); | |
| } | |
| }; | |
| let ignore_program_ids: HashSet<u32> = invalid_program_ids.into_iter().collect(); | |
| let dir_containing_programs: PathBuf = self.config.loda_programs_oeis_dir(); | |
| let paths: Vec<PathBuf> = find_asm_files_recursively(&dir_containing_programs); | |
| let number_of_paths = paths.len(); | |
| if number_of_paths <= 0 { | |
| return Err(anyhow::anyhow!("Expected 1 or more programs, but there are no programs to analyze")); | |
| } | |
| println!("Exporting {} LODA programs", paths.len()); | |
| let pb = ProgressBar::new(number_of_paths as u64); | |
| let start = Instant::now(); | |
| for path in paths { | |
| self.process_program_file(&path, &ignore_program_ids)?; | |
| pb.inc(1); | |
| } | |
| pb.finish_and_clear(); | |
| let green_bold = Style::new().green().bold(); | |
| println!( | |
| "{:>12} exported dataset in {}", | |
| green_bold.apply_to("Finished"), | |
| HumanDuration(start.elapsed()) | |
| ); | |
| if self.count_ignored > 0 { | |
| println!("count_ignored: {}", self.count_ignored); | |
| } | |
| if self.count_insufficient_number_of_terms > 0 { | |
| println!("count_insufficient_number_of_terms: {}", self.count_insufficient_number_of_terms); | |
| } | |
| Ok(()) | |
| } | |
| fn process_program_file(&mut self, path_to_program: &Path, ignore_program_ids: &HashSet<u32>) -> anyhow::Result<()> { | |
| let program_id: u32 = match oeis_id_from_path(path_to_program) { | |
| Some(oeis_id) => oeis_id.raw(), | |
| None => { | |
| return Err(anyhow::anyhow!("Unable to extract program_id from {:?}", path_to_program)); | |
| } | |
| }; | |
| if ignore_program_ids.contains(&program_id) { | |
| self.count_ignored += 1; | |
| return Ok(()); | |
| } | |
| let oeis_id = OeisId::from(program_id); | |
| let terms: String = match self.oeis_id_to_terms_set.get(&oeis_id) { | |
| Some(value) => { | |
| value.clone() | |
| }, | |
| None => { | |
| self.count_insufficient_number_of_terms += 1; | |
| return Ok(()); | |
| } | |
| }; | |
| let contents: String = match fs::read_to_string(&path_to_program) { | |
| Ok(value) => value, | |
| Err(error) => { | |
| return Err(anyhow::anyhow!("loading program_id: {:?}, something went wrong reading the file: {:?}", program_id, error)); | |
| } | |
| }; | |
| let parsed_program: ParsedProgram = match ParsedProgram::parse_program(&contents) { | |
| Ok(value) => value, | |
| Err(error) => { | |
| return Err(anyhow::anyhow!("parsing program_id: {:?}, something went wrong parsing the file: {:?}", program_id, error)); | |
| } | |
| }; | |
| let instructions: Vec<String> = parsed_program.instruction_vec.iter().map(|instruction| { | |
| instruction.to_string() | |
| }).collect(); | |
| let instructions_joined: String = instructions.join("\\n"); | |
| let record = Record { | |
| program_id: program_id, | |
| terms: terms, | |
| program: instructions_joined | |
| }; | |
| self.records.push(record); | |
| Ok(()) | |
| } | |
| /// Save as a CSV file | |
| fn save(&self) -> anyhow::Result<()> { | |
| let mut records: Vec<Record> = self.records.clone(); | |
| records.sort_unstable_by_key(|item| (item.program_id)); | |
| let output_path: PathBuf = self.config.analytics_oeis_dir().join("dataset.csv"); | |
| match create_csv_file(&records, &output_path) { | |
| Ok(_) => {}, | |
| Err(error) => { | |
| return Err(anyhow::anyhow!("Unable to save csv file at {:?}, error: {:?}", output_path, error)); | |
| } | |
| } | |
| Ok(()) | |
| } | |
| } | |
| struct Record { | |
| program_id: u32, | |
| terms: String, | |
| program: String, | |
| } | |