Download loda-rust/rust_project/loda-rust-cli/src/subcommand_pattern.rs from Alignment-Lab-AI/ARC-stuff: direct link, hf CLI and curl.
- Browser
- Download file 19.4 kB
-
https://huggingface.co/datasets/Alignment-Lab-AI/ARC-stuff/resolve/main/loda-rust/rust_project/loda-rust-cli/src/subcommand_pattern.rs
- Command line
-
hf download hf://datasets/Alignment-Lab-AI/ARC-stuff/loda-rust/rust_project/loda-rust-cli/src/subcommand_pattern.rs
-
curl -L -o subcommand_pattern.rs https://huggingface.co/datasets/Alignment-Lab-AI/ARC-stuff/resolve/main/loda-rust/rust_project/loda-rust-cli/src/subcommand_pattern.rs
19.4 kB
| //! The `loda-rust pattern` subcommand, identifies recurring patterns. | |
| use crate::common::{find_asm_files_recursively, find_csv_files_recursively, oeis_id_from_path, parse_csv_file}; | |
| use crate::pattern::{Clusters, instruction_diff_between_constants, ProgramSimilarity, RecordSimilar}; | |
| use crate::config::Config; | |
| use loda_rust_core::parser::{Instruction, InstructionId, ParsedProgram}; | |
| use std::time::Instant; | |
| use std::path::{Path, PathBuf}; | |
| use std::fs; | |
| use std::fs::File; | |
| use std::io::prelude::*; | |
| use std::collections::HashSet; | |
| use std::collections::HashMap; | |
| use std::error::Error; | |
| use std::rc::Rc; | |
| use std::iter::FromIterator; | |
| const PROGRAM_LENGTH_MINIMUM: usize = 1; | |
| const PROGRAM_LENGTH_MAXIMUM: usize = 80; | |
| const MINIMUM_NUMBER_OF_SIMILAR_PROGRAMS_BEFORE_ITS_A_PATTERN: usize = 15; | |
| const DISCARD_PATTERNS_WITHOUT_ANY_PARAMETERS: bool = true; | |
| /// Identify recurring patterns among similar programs. | |
| pub struct SubcommandPattern { | |
| append_verbose_details: bool, | |
| } | |
| impl SubcommandPattern { | |
| pub fn run(append_verbose_details: bool) { | |
| let instance = Self { | |
| append_verbose_details: append_verbose_details | |
| }; | |
| instance.run_inner(); | |
| } | |
| fn run_inner(&self) { | |
| let start_time = Instant::now(); | |
| let config = Config::load(); | |
| let loda_programs_oeis_dir: PathBuf = config.loda_programs_oeis_dir(); | |
| let similar_programs: PathBuf = config.similar_programs(); | |
| let output_dir: PathBuf = config.loda_patterns_repository_simple_constant(); | |
| // Find all similarity CSV files. | |
| let mut similarity_csv_paths: Vec<PathBuf> = find_csv_files_recursively(&similar_programs); | |
| similarity_csv_paths.sort(); | |
| let number_of_similarity_csv_paths = similarity_csv_paths.len(); | |
| if number_of_similarity_csv_paths <= 0 { | |
| error!("Expected 1 or more similarity csv files, but there are none to analyze"); | |
| return; | |
| } | |
| debug!("number of similarity csv files: {}", number_of_similarity_csv_paths); | |
| let mut csv_vec = Vec::<Rc<SimilarityCSVFile>>::new(); | |
| for path in similarity_csv_paths { | |
| let program_id: u32 = match oeis_id_from_path(&path) { | |
| Some(oeis_id) => oeis_id.raw(), | |
| None => { continue; } | |
| }; | |
| let instance = SimilarityCSVFile::new(program_id, path); | |
| csv_vec.push(Rc::new(instance)); | |
| } | |
| let mut program_id_to_csv_hashmap = ProgramIdToSimilarityCSVFile::new(); | |
| for csv_item in csv_vec { | |
| program_id_to_csv_hashmap.insert(csv_item.program_id, Rc::clone(&csv_item)); | |
| } | |
| let number_of_items_in_csv_hashmap = program_id_to_csv_hashmap.len(); | |
| if number_of_items_in_csv_hashmap <= 0 { | |
| error!("Expected 1 or more similarity csv files, but there are none to analyze"); | |
| return; | |
| } | |
| debug!("number of unique program_ids in csv hashmap: {:?}", number_of_items_in_csv_hashmap); | |
| // Find all programs. | |
| let mut program_asm_paths: Vec<PathBuf> = find_asm_files_recursively(&loda_programs_oeis_dir); | |
| program_asm_paths.sort(); | |
| let number_of_program_asm_paths = program_asm_paths.len(); | |
| if number_of_program_asm_paths <= 0 { | |
| error!("Expected 1 or more program asm files, but there are none to analyze"); | |
| return; | |
| } | |
| debug!("number of program asm files: {}", number_of_program_asm_paths); | |
| // Parse all programs. | |
| // Ignoring too short/long programs. | |
| let mut program_meta_vec = Vec::<Rc<ProgramMeta>>::new(); | |
| for path in program_asm_paths { | |
| let program_meta = match self.analyze_program(&path) { | |
| Some(value) => value, | |
| None => { | |
| continue; | |
| } | |
| }; | |
| program_meta_vec.push(Rc::new(program_meta)); | |
| } | |
| debug!("number of program_meta items: {}", program_meta_vec.len()); | |
| // Obtain the number of lines of all programs. | |
| let mut line_count_set = HashSet::<u16>::new(); | |
| for program_meta in &program_meta_vec { | |
| line_count_set.insert(program_meta.line_count); | |
| } | |
| let mut line_count_vec: Vec<u16> = line_count_set.into_iter().collect(); | |
| line_count_vec.sort(); | |
| debug!("line_count's: {:?}", line_count_vec); | |
| self.traverse_by_line_count( | |
| &line_count_vec, | |
| &program_meta_vec, | |
| &program_id_to_csv_hashmap, | |
| &output_dir, | |
| ); | |
| println!("elapsed: {:?} ms", start_time.elapsed().as_millis()); | |
| } | |
| fn traverse_by_line_count( | |
| &self, | |
| line_count_vec: &Vec<u16>, | |
| program_meta_vec: &Vec<Rc<ProgramMeta>>, | |
| program_id_to_similarity_csv_file: &ProgramIdToSimilarityCSVFile, | |
| output_dir: &Path, | |
| ) { | |
| for line_count in line_count_vec { | |
| let mut programs_with_same_length = Vec::<Rc<ProgramMeta>>::new(); | |
| for program_meta in program_meta_vec { | |
| if program_meta.line_count != *line_count { | |
| continue; | |
| } | |
| programs_with_same_length.push(Rc::clone(program_meta)); | |
| } | |
| self.process_programs_with_same_length( | |
| *line_count, | |
| &programs_with_same_length, | |
| program_id_to_similarity_csv_file, | |
| output_dir, | |
| ); | |
| } | |
| } | |
| fn process_programs_with_same_length( | |
| &self, | |
| line_count: u16, | |
| program_meta_vec: &Vec<Rc<ProgramMeta>>, | |
| program_id_to_similarity_csv_file: &ProgramIdToSimilarityCSVFile, | |
| output_dir: &Path, | |
| ) { | |
| println!("line count: {:?} number of programs: {:?}", line_count, program_meta_vec.len()); | |
| // Build a hashmap of programs with the same number of lines | |
| let mut program_id_to_program_meta_hashmap = ProgramIdToProgramMeta::new(); | |
| for program_meta_item in program_meta_vec { | |
| program_id_to_program_meta_hashmap.insert(program_meta_item.program_id, Rc::clone(&program_meta_item)); | |
| } | |
| let mut number_of_similarity_records: usize = 0; | |
| let mut clusters = Clusters::new(); | |
| for program_meta in program_meta_vec { | |
| let program_id: u32 = program_meta.program_id; | |
| // Find corresponding similarity csv file | |
| let csv_file: Rc<SimilarityCSVFile> = match program_id_to_similarity_csv_file.get(&program_id) { | |
| Some(value) => Rc::clone(value), | |
| None => { | |
| debug!("ignoring program_id: {}, because it's missing a similarity csv file", program_id); | |
| continue; | |
| } | |
| }; | |
| // Parse the similarity csv file | |
| let similarity_records: Vec<RecordSimilar> = match parse_csv_file(&csv_file.path) { | |
| Ok(value) => value, | |
| Err(error) => { | |
| debug!("ignoring program_id: {}. cannot load csv file {:?}", program_id, error); | |
| continue; | |
| } | |
| }; | |
| number_of_similarity_records += similarity_records.len(); | |
| // Compare this program with each rows in the csv file | |
| self.find_patterns( | |
| program_id, | |
| &similarity_records, | |
| &program_id_to_program_meta_hashmap, | |
| &mut clusters | |
| ); | |
| } | |
| debug!("number of records: {}", number_of_similarity_records); | |
| let mut clusters_of_programids: Vec<HashSet<u32>> = clusters.clusters_of_programids(); | |
| // Keep only the patterns that repeats a lot. | |
| // Eliminate patterns that rarely occurs. | |
| let number_of_all_clusters: usize = clusters_of_programids.len(); | |
| clusters_of_programids.retain(|program_id_set| program_id_set.len() >= MINIMUM_NUMBER_OF_SIMILAR_PROGRAMS_BEFORE_ITS_A_PATTERN); | |
| let number_of_patterns: usize = clusters_of_programids.len(); | |
| debug!("number of clusters: {}", number_of_all_clusters); | |
| println!("number of patterns: {}", number_of_patterns); | |
| for program_id_set in clusters_of_programids { | |
| let save_result = self.save_pattern(line_count, &program_id_set, &program_id_to_program_meta_hashmap, output_dir); | |
| match save_result { | |
| Ok(_) => {}, | |
| Err(error) => { | |
| error!("Unable to save result. {:?}", error); | |
| } | |
| } | |
| } | |
| } | |
| fn save_pattern( | |
| &self, | |
| line_count: u16, | |
| program_id_set: &HashSet<u32>, | |
| program_id_to_program_meta_hashmap: &ProgramIdToProgramMeta, | |
| output_dir: &Path | |
| ) -> Result<(), Box<dyn Error>> { | |
| let lowest_program_id: u32 = match Clusters::lowest_program_id_in_set(program_id_set) { | |
| Some(value) => value, | |
| None => { | |
| error!("unable to find lowest program id."); | |
| return Ok(()); | |
| } | |
| }; | |
| let original_program_meta: Rc<ProgramMeta> = match program_id_to_program_meta_hashmap.get(&lowest_program_id) { | |
| Some(value) => Rc::clone(value), | |
| None => { | |
| debug!("ignoring program: {}. there is no asm file.", lowest_program_id); | |
| return Ok(()); | |
| } | |
| }; | |
| let mut line_number_to_value_set = HashMap::<usize, HashSet<i64>>::new(); | |
| for program_id_item in program_id_set { | |
| let similar_program_meta: Rc<ProgramMeta> = match program_id_to_program_meta_hashmap.get(&program_id_item) { | |
| Some(value) => Rc::clone(value), | |
| None => { | |
| continue; | |
| } | |
| }; | |
| let instruction_vec0 = &original_program_meta.parsed_program.instruction_vec; | |
| let instruction_vec1 = &similar_program_meta.parsed_program.instruction_vec; | |
| // Reject if the number of instructions differs | |
| if instruction_vec0.len() != instruction_vec1.len() { | |
| continue; | |
| } | |
| // Reject if the instructions differs | |
| for index in 0..instruction_vec0.len() { | |
| if instruction_vec0[index].instruction_id != instruction_vec1[index].instruction_id { | |
| continue; | |
| } | |
| } | |
| for index in 0..instruction_vec0.len() { | |
| let instruction0: &Instruction = &instruction_vec0[index]; | |
| let instruction1: &Instruction = &instruction_vec1[index]; | |
| // If the instructions have different constants | |
| // then remember the line number and the constants. | |
| let diff = instruction_diff_between_constants(instruction0, instruction1); | |
| if let Some((constant0, constant1)) = diff { | |
| let entry = line_number_to_value_set.entry(index).or_insert_with(|| HashSet::new()); | |
| entry.insert(constant0); | |
| entry.insert(constant1); | |
| } | |
| } | |
| } | |
| let mut annotated_program = String::with_capacity(4000); | |
| let instruction_vec = &original_program_meta.parsed_program.instruction_vec; | |
| let mut indentation: usize = 0; | |
| let mut pretty_parameters = Vec::<String>::new(); | |
| for index in 0..instruction_vec.len() { | |
| let instruction: &Instruction = &instruction_vec[index]; | |
| if index > 0 { | |
| annotated_program.push_str("\n"); | |
| } | |
| // Indent nested loops | |
| if instruction.instruction_id == InstructionId::LoopEnd { | |
| if indentation > 0 { | |
| indentation -= 1; | |
| } | |
| } | |
| for _ in 0..indentation { | |
| annotated_program.push_str(" "); | |
| } | |
| if instruction.instruction_id == InstructionId::LoopBegin { | |
| indentation += 1; | |
| } | |
| // The instruction | |
| annotated_program.push_str(&format!("{}", instruction)); | |
| let value_set: &HashSet<i64> = match line_number_to_value_set.get(&index) { | |
| Some(value) => value, | |
| None => { | |
| continue; | |
| } | |
| }; | |
| // The parameter index | |
| let parameter_index = pretty_parameters.len(); | |
| annotated_program.push_str(" ; "); | |
| annotated_program.push_str(&format!("source=parameter {}", parameter_index)); | |
| // Format the parameter values | |
| let mut value_vec: Vec<&i64> = Vec::from_iter(value_set); | |
| value_vec.sort(); | |
| let value_strings: Vec<String> = value_vec.iter().map(|value| format!("{}", value) ).collect(); | |
| let mut formatted_parameter = String::with_capacity(1000); | |
| formatted_parameter.push_str(&format!("; parameter {}\n", parameter_index)); | |
| formatted_parameter.push_str(&format!("; number of unique values: {}\n", value_set.len())); | |
| formatted_parameter.push_str("; value: "); | |
| formatted_parameter.push_str(&value_strings.join(",")); | |
| pretty_parameters.push(formatted_parameter); | |
| } | |
| let number_of_parameters: usize = line_number_to_value_set.len(); | |
| if DISCARD_PATTERNS_WITHOUT_ANY_PARAMETERS && number_of_parameters == 0 { | |
| return Ok(()); | |
| } | |
| // Convert program_ids to a formatted string | |
| let mut program_ids: Vec<u32> = program_id_set.iter().map(|program_id| *program_id).collect(); | |
| program_ids.sort(); | |
| let program_id_strings: Vec<String> = program_ids.iter().map(|program_id| format!("{}", program_id)).collect(); | |
| let formatted_program_ids: String = program_id_strings.join(","); | |
| // File content | |
| let mut content = String::with_capacity(4000); | |
| content += &annotated_program; | |
| content += "\n"; | |
| if self.append_verbose_details { | |
| content += "\n"; | |
| if !pretty_parameters.is_empty() { | |
| content += &pretty_parameters.join("\n\n"); | |
| content += "\n\n"; | |
| } | |
| content += "; programs with this pattern\n"; | |
| content += &format!("; number of programs: {:?}\n", program_id_set.len()); | |
| content += "; program id: "; | |
| content += &formatted_program_ids; | |
| content += "\n"; | |
| } | |
| // Version control of the found patterns. | |
| // Ideally pick a filename that stays the same, no matter how many programs follow the same pattern. | |
| // The number of lines in the patterns doesn't change. | |
| // The number of parameters changes, if new programs starts making creative parameter changes. | |
| // The OEIS sequence id of the lowest program. This changes if it has started using another pattern. | |
| let filename = format!("lines{}_parameters{}_A{}.asm", line_count, number_of_parameters, lowest_program_id); | |
| let path: PathBuf = output_dir.join(Path::new(&filename)); | |
| let mut file = File::create(path)?; | |
| file.write_all(content.as_bytes())?; | |
| Ok(()) | |
| } | |
| fn find_patterns( | |
| &self, | |
| program_id: u32, | |
| similarity_records: &Vec<RecordSimilar>, | |
| program_id_to_program_meta_hashmap: &ProgramIdToProgramMeta, | |
| clusters: &mut Clusters, | |
| ) { | |
| let original_program_meta: Rc<ProgramMeta> = match program_id_to_program_meta_hashmap.get(&program_id) { | |
| Some(value) => Rc::clone(value), | |
| None => { | |
| debug!("ignoring program: {}. there is no asm file.", program_id); | |
| return; | |
| } | |
| }; | |
| let mut highly_similar_programs = Vec::<Rc<ProgramMeta>>::with_capacity(26); | |
| for record in similarity_records { | |
| let similar_program_meta: Rc<ProgramMeta> = match program_id_to_program_meta_hashmap.get(&record.program_id) { | |
| Some(value) => Rc::clone(value), | |
| None => { | |
| continue; | |
| } | |
| }; | |
| let similarity = ProgramSimilarity::measure_similarity( | |
| &original_program_meta.parsed_program.instruction_vec, | |
| &similar_program_meta.parsed_program.instruction_vec | |
| ); | |
| match similarity { | |
| ProgramSimilarity::NotSimilar => { | |
| continue; | |
| }, | |
| ProgramSimilarity::SimilarWithDifferentConstants(_) => { | |
| highly_similar_programs.push(similar_program_meta); | |
| } | |
| } | |
| } | |
| highly_similar_programs.push(original_program_meta); | |
| let highly_similar_program_ids: Vec<u32> = highly_similar_programs.iter().map(|pm|pm.program_id).collect(); | |
| // println!("program id: {} has many similar with minor diffs to constants: {:?}", program_id, highly_similar_program_ids); | |
| clusters.insert(&highly_similar_program_ids); | |
| } | |
| fn analyze_program( | |
| &self, | |
| path: &Path, | |
| ) -> Option<ProgramMeta> { | |
| let program_id: u32 = match oeis_id_from_path(path) { | |
| Some(oeis_id) => oeis_id.raw(), | |
| None => { | |
| return None; | |
| } | |
| }; | |
| let parsed_program: ParsedProgram = match self.load_program(path) { | |
| Some(value) => value, | |
| None => { | |
| return None; | |
| } | |
| }; | |
| let line_count_raw: usize = parsed_program.instruction_vec.len(); | |
| if line_count_raw < PROGRAM_LENGTH_MINIMUM { | |
| return None; | |
| } | |
| if line_count_raw > PROGRAM_LENGTH_MAXIMUM { | |
| error!("analyze_program. Skipping a program that is too long. path: {:?}", path); | |
| return None; | |
| } | |
| Some(ProgramMeta::new(program_id, line_count_raw as u16, parsed_program)) | |
| } | |
| fn load_program( | |
| &self, | |
| path: &Path | |
| ) -> Option<ParsedProgram> { | |
| let contents: String = match fs::read_to_string(path) { | |
| Ok(value) => value, | |
| Err(error) => { | |
| error!("load program, error: {:?} path: {:?}", error, path); | |
| return None; | |
| } | |
| }; | |
| let parsed_program: ParsedProgram = match ParsedProgram::parse_program(&contents) { | |
| Ok(value) => value, | |
| Err(error) => { | |
| error!("load program, error: {:?} path: {:?}", error, path); | |
| return None; | |
| } | |
| }; | |
| Some(parsed_program) | |
| } | |
| } | |
| struct ProgramMeta { | |
| program_id: u32, | |
| line_count: u16, | |
| parsed_program: ParsedProgram, | |
| } | |
| impl ProgramMeta { | |
| fn new(program_id: u32, line_count: u16, parsed_program: ParsedProgram) -> Self { | |
| Self { | |
| program_id: program_id, | |
| line_count: line_count, | |
| parsed_program: parsed_program, | |
| } | |
| } | |
| } | |
| type ProgramIdToProgramMeta = HashMap::<u32, Rc::<ProgramMeta>>; | |
| struct SimilarityCSVFile { | |
| program_id: u32, | |
| path: PathBuf, | |
| } | |
| impl SimilarityCSVFile { | |
| fn new(program_id: u32, path: PathBuf) -> Self { | |
| Self { | |
| program_id: program_id, | |
| path: path | |
| } | |
| } | |
| } | |
| type ProgramIdToSimilarityCSVFile = HashMap::<u32, Rc::<SimilarityCSVFile>>; | |