def assess_goal_directed_generation( goal_directed_molecule_generator: GoalDirectedGenerator, json_output_file='output_goal_directed.json', benchmark_version='v3') -> None: """ Assesses a distribution-matching model for de novo molecule design. Args: goal_directed_molecule_generator: Model to evaluate json_output_file: Name of the file where to save the results in JSON format benchmark_version: which benchmark suite to execute """ logger.info( f'Benchmarking goal-directed molecule generation, version {benchmark_version}' ) benchmarks = goal_directed_benchmark_suite(version_name=benchmark_version) results = _evaluate_goal_directed_benchmarks( goal_directed_molecule_generator=goal_directed_molecule_generator, benchmarks=benchmarks) benchmark_results: Dict[str, Any] = OrderedDict() benchmark_results['guacamol_version'] = guacamol.__version__ benchmark_results['benchmark_suite_version'] = benchmark_version benchmark_results['timestamp'] = get_time_string() benchmark_results['results'] = [vars(result) for result in results] logger.info(f'Save results to file {json_output_file}') with open(json_output_file, 'wt') as f: f.write(json.dumps(benchmark_results, indent=4))
def Main(): # Parse the command line arguments. args = ParseArgs() # Create a pool of worker threads. thread_pool = joblib.Parallel(n_jobs=args.n_threads) # Load the SMILES of the input file into memory. smiles = LoadSMILES(thread_pool, args.input) print(f"{len(smiles)} SMILES loaded.") # Loop over the individual benchmarks in the benchmark suite. starting_populations = {} benchmarks = goal_directed_benchmark_suite( version_name=args.benchmark_suite_version) for benchmark in benchmarks: # Determine the number of molecules to write out. n = args.n_molecules n_requested = max(benchmark.contribution_specification.top_counts) if n_requested > n: n = n_requested # Use the benchmark's scoring function to score the loaded SMILES. start_time = time.time() print(f"Scoring molecules with '{benchmark.name}' scoring function.") top_n_smiles = TopN(thread_pool, smiles, benchmark.objective, n) time_spend = time.time() - start_time print(f"{time_spend}s spent retrieving {len(top_n_smiles)} molecules.") # Store the best molecules. starting_populations[benchmark.name] = top_n_smiles # Write the molecules to the output JSON file. with open(args.output, "w") as file: json.dump(starting_populations, file, indent=4)
def Main(): # Parse the command line arguments. args = ParseArgs() # Read the starting populations JSON. These are supposed to be the top N # molecules found by screening the GuacaMol "all" dataset using the same scoring # functions as the GuacaMol benchmark suite. In the original GuacaMol examples # this step is done as part of the benchmark, but since that implies repeating # the virtual screen for every replica I've separated it. benchmark_starting_populations = None if args.starting_populations: benchmark_starting_populations = LoadStartingPopulations(args.starting_populations) # Iterate over the specified benchmarks. benchmarks = goal_directed_benchmark_suite(version_name=args.benchmark_suite_version) for benchmark_id in args.benchmark_ids: benchmark = benchmarks[benchmark_id - 1] print(f"Current benchmark: {benchmark.name}") # Fetch the appropiate starting population for the benchmark. starting_population = None if args.starting_populations: starting_population = benchmark_starting_populations[benchmark.name] # Create an output directory for the benchmark. benchmark_output_directory = os.path.join(args.output_directory, str(benchmark_id)) os.mkdir(benchmark_output_directory) # Initialize a LEADD instance. leadd = LEADD(fragmentation_settings_file=args.fragmentation_settings_file, reconstruction_settings_file=args.reconstruction_settings_file, output_directory=benchmark_output_directory, starting_population=starting_population, benchmark=benchmark, n_threads=args.n_threads) # Use the benchmark to assess LEADD's performance. benchmark_result = benchmark.assess_model(leadd) # Add finer-grained computational performance data to the result's metadata. leadd.add_performance_data_to_guacamol_benchmark_result(benchmark_result) # Write the genetic operation frequencies to the report. leadd.leadd.WriteOperationFrequenciesToReport() # Release all LEADD resources. leadd.clean_up() # Write the results to a JSON file. output_json_path = os.path.join(benchmark_output_directory, "goal_directed_results.json") WriteGuacaMolBenchmarkResult(benchmark_result, output_json_path)
def generate_optimized_molecules(self, scoring_function: ScoringFunction, number_molecules: int, starting_population: Optional[List[str]] = None) -> List[str]: """ Given an objective function, generate molecules that score as high as possible. Args: scoring_function: scoring function number_molecules: number of molecules to generate starting_population: molecules to start the optimization from (optional) Returns: A list of SMILES strings for the generated molecules. """ benchmarks = goal_directed_benchmark_suite(self.version) cache_files = ['guac_v2_{}do_0.5_lr4e-5_mark'.format(idx) for idx in range(20)] #TODO: put the directory for the cache file here gen = DummyMoleculeGenerator([cache_files[19]], maximize_reward=True) self.obj_num += 1 if self.obj_num == self.num_benchmarks: self.obj_num == 0 return gen.generate(number_molecules)
def __init__(self, version): self.version = version self.num_benchmarks = len(goal_directed_benchmark_suite(self.version)) self.obj_num = 0
def guacamol_goal_scoring_functions(version_name): assert version_name in version_name_list, "Version name must be in " + str(version_name_list) benchmarks = goal_directed_benchmark_suite(version_name=version_name) out = [GuacamolGoalWrapper(b) for b in benchmarks] return out