├── LICENSE.txt ├── README.md ├── configs ├── ADV.json ├── ROCS.json ├── al_parameter_defs.md ├── bash_script.sh ├── cleanup_script.sh └── reinvent.json ├── data ├── CoX2 │ ├── 1cx2_ligand.pdbqt │ ├── 1cx2_ligand_explicitH.pdbqt │ ├── 1cx2_ligand_explicitH.sdf │ ├── 1cx2_ligandoutpose.pdbqt │ ├── 1cx2_monomer_apo.pdbqt │ └── shape_query │ │ ├── S58.sdf │ │ └── S58.sq ├── RXRa │ ├── 2p1t_apo.pdb │ ├── 2p1t_apo.pdbqt │ ├── 2p1t_apo_explicitH.pdb │ ├── 2p1t_apo_explicitH_minimised.pdb │ ├── 2p1t_apo_schrodinger.pdb │ ├── 2p1t_ligand.pdbqt │ ├── 2p1t_ligand.sdf │ ├── 2p1t_ligand_explicitH.pdbqt │ ├── 2p1t_ligand_explicitH.sdf │ ├── 2p1t_ligand_explicitH_out.pdbqt │ ├── 2p1t_ligand_explicitH_schrodinger.pdb │ ├── 2p1t_ligandoutpose.pdbqt │ ├── minimised │ │ ├── 2p1t_apo_explicitH_minimised.pdb │ │ ├── 2p1t_apo_explicitH_minimised.pdbqt │ │ ├── 2p1t_ligand.sdf │ │ ├── 2p1t_ligand_explicitH.pdb │ │ ├── 2p1t_ligand_explicitH.pdbqt │ │ ├── 2p1t_ligand_explicitH.sdf │ │ ├── 2p1t_ligandoutpose.pdbqt │ │ └── vina_config.txt │ └── vina_config.txt └── reinvent_prior │ └── random.prior.new ├── icolos ├── .gitignore ├── CHANGELOG.md ├── LICENCE ├── README.md ├── environment_min.yml ├── examples │ ├── hpc_script │ │ ├── NIBR_reinvent.sh │ │ ├── REINVENT_script.sh │ │ └── SLURM_script.sh │ └── workflow │ │ ├── desmond_md.json │ │ ├── docking │ │ ├── active_learning_docking.json │ │ ├── adv_docking.json │ │ ├── adv_target_preparation.json │ │ ├── generic.json │ │ ├── glide_docking.json │ │ └── gold_docking.json │ │ ├── fep_plus │ │ └── fep_plus_aws.json │ │ ├── gromacs │ │ ├── gromacs_ensemble_mmgbsa.json │ │ ├── gromacs_ensemble_mmgbsa_replex.json │ │ ├── gromacs_md.json │ │ ├── gromacs_md_cluster_rmsd.json │ │ ├── gromacs_mmgbsa.json │ │ ├── gromacs_post.json │ │ └── gromacs_post.yml │ │ ├── input_file_types.json │ │ ├── pmx │ │ ├── pmx_abfe.json │ │ ├── pmx_protein_rbfe.json │ │ ├── pmx_rbfe.json │ │ └── smiles_to_ddg_adv.json │ │ ├── qm │ │ ├── boltzmann_rew_vector.json │ │ ├── ePSA_permeability.json │ │ ├── full_rescoss.json │ │ ├── jazzy.json │ │ └── kallisto.json │ │ ├── reinvent │ │ ├── ensemble_docking_reinvent.json │ │ ├── feature_counter.json │ │ ├── icolos_component.json │ │ └── nibr_local_reinvent.json │ │ └── rescoring │ │ ├── negative_image_panther.json │ │ ├── nibr_local.json │ │ └── rmsd_rescoring.json ├── external_documentation │ ├── REINVENT_input.json │ ├── REINVENT_result.json │ ├── fep_mapper.txt │ ├── fep_plus.txt │ ├── gold.conf │ └── prime_arguments.txt ├── licences │ └── espsim_licence.txt ├── pyproject.toml ├── setup.py ├── src │ └── icolos │ │ ├── __init__.py │ │ ├── config │ │ ├── amber │ │ │ └── default_mmpbsa.in │ │ ├── cosmo │ │ │ └── default_cosmo.config │ │ ├── desmond │ │ │ ├── config.msj │ │ │ ├── prod.cfg │ │ │ └── production.msj │ │ ├── logging │ │ │ ├── debug.json │ │ │ ├── default.json │ │ │ ├── tutorial.json │ │ │ └── verbose.json │ │ ├── panther │ │ │ └── default_panther.in │ │ ├── schemas │ │ │ ├── header.json │ │ │ ├── schemas.py │ │ │ ├── step.json │ │ │ ├── step_execution.json │ │ │ ├── step_input.json │ │ │ ├── step_writeout.json │ │ │ └── workflow.json │ │ └── unit_tests_config │ │ │ ├── cosmo │ │ │ ├── cosmo.config │ │ │ └── example.cosmo.config │ │ │ └── example.config.json │ │ ├── config_containers │ │ ├── __init__.py │ │ ├── container.py │ │ └── workflow_container.py │ │ ├── core │ │ ├── __init__.py │ │ ├── composite_agents │ │ │ ├── __init__.py │ │ │ ├── base_agent.py │ │ │ ├── scheduler.py │ │ │ └── workflow.py │ │ ├── containers │ │ │ ├── __init__.py │ │ │ ├── compound.py │ │ │ ├── generic.py │ │ │ ├── gmx_state.py │ │ │ └── perturbation_map.py │ │ ├── flow_control │ │ │ ├── __init__.py │ │ │ ├── flow_control.py │ │ │ └── iterator.py │ │ ├── step_dispatch │ │ │ ├── __init__.py │ │ │ └── dispatcher.py │ │ ├── step_utils │ │ │ ├── __init__.py │ │ │ ├── gold_config.py │ │ │ ├── input_merger.py │ │ │ ├── input_preparator.py │ │ │ ├── obabel_structconvert.py │ │ │ ├── rdkit_utils.py │ │ │ ├── retry.py │ │ │ ├── run_variables_resolver.py │ │ │ ├── sdconvert_util.py │ │ │ ├── step_writeout.py │ │ │ ├── structcat_util.py │ │ │ └── structconvert.py │ │ ├── steps_utils.py │ │ └── workflow_steps │ │ │ ├── __init__.py │ │ │ ├── autodockvina │ │ │ ├── __init__.py │ │ │ ├── docking.py │ │ │ └── target_preparation.py │ │ │ ├── calculation │ │ │ ├── __init__.py │ │ │ ├── base.py │ │ │ ├── boltzmann_weighting.py │ │ │ ├── clustering.py │ │ │ ├── cosmo.py │ │ │ ├── cresset_ec.py │ │ │ ├── esp_sim.py │ │ │ ├── feature_counter.py │ │ │ ├── generic_score.py │ │ │ ├── jazzy.py │ │ │ ├── kallisto.py │ │ │ ├── lomap.py │ │ │ ├── panther.py │ │ │ ├── rms_filter.py │ │ │ ├── rmsd.py │ │ │ ├── shaep.py │ │ │ └── turbomole.py │ │ │ ├── ccdc │ │ │ ├── __init__.py │ │ │ └── docking.py │ │ │ ├── confgen │ │ │ ├── __init__.py │ │ │ ├── base.py │ │ │ ├── crest.py │ │ │ ├── omega.py │ │ │ └── xtb.py │ │ │ ├── fpocket │ │ │ ├── __init__.py │ │ │ ├── base.py │ │ │ └── mdpocket.py │ │ │ ├── gromacs │ │ │ ├── __init__.py │ │ │ ├── base.py │ │ │ ├── cluster.py │ │ │ ├── clusters_ts.py │ │ │ ├── do_dssp.py │ │ │ ├── editconf.py │ │ │ ├── genion.py │ │ │ ├── grompp.py │ │ │ ├── mdrun.py │ │ │ ├── mmpbsa.py │ │ │ ├── pdb2gmx.py │ │ │ ├── postprocess.py │ │ │ ├── rsmd.py │ │ │ ├── select.py │ │ │ ├── solvate.py │ │ │ ├── trajcat.py │ │ │ └── trjconv.py │ │ │ ├── io │ │ │ ├── __init__.py │ │ │ ├── base.py │ │ │ ├── data_manipulation.py │ │ │ ├── embedder.py │ │ │ └── initialize_compound.py │ │ │ ├── openff │ │ │ ├── __init__.py │ │ │ └── openff2gmx.py │ │ │ ├── pmx │ │ │ ├── __init__.py │ │ │ ├── abfe.py │ │ │ ├── assemble_systems.py │ │ │ ├── atomMapping.py │ │ │ ├── base.py │ │ │ ├── box_water_ions.py │ │ │ ├── doublebox.py │ │ │ ├── genlib.py │ │ │ ├── gentop.py │ │ │ ├── ligandHybrid.py │ │ │ ├── mutate.py │ │ │ ├── prepare_simulations.py │ │ │ ├── prepare_transitions.py │ │ │ ├── run_analysis.py │ │ │ ├── run_simulations.py │ │ │ └── setup_workpath.py │ │ │ ├── prediction │ │ │ ├── __init__.py │ │ │ ├── model_building.py │ │ │ └── predictor.py │ │ │ ├── schrodinger │ │ │ ├── __init__.py │ │ │ ├── base.py │ │ │ ├── desmond_exec.py │ │ │ ├── desmond_preprocessor.py │ │ │ ├── fep_absolute.py │ │ │ ├── fep_analysis.py │ │ │ ├── fep_base.py │ │ │ ├── fep_plus_execution.py │ │ │ ├── fep_plus_setup.py │ │ │ ├── glide.py │ │ │ ├── ligprep.py │ │ │ ├── macromodel.py │ │ │ ├── prepwizard.py │ │ │ ├── prime.py │ │ │ ├── protein_interaction.py │ │ │ └── residue_scanning.py │ │ │ ├── step.py │ │ │ └── structure_prediction │ │ │ ├── __init__.py │ │ │ ├── disicl.py │ │ │ ├── dssp.py │ │ │ ├── pdb_fixer.py │ │ │ ├── peptide_embedder.py │ │ │ └── rosetta_abinitio.py │ │ ├── loggers │ │ ├── __init__.py │ │ ├── agentlogger.py │ │ ├── base_logger.py │ │ ├── blank_logger.py │ │ ├── entrypoint_logger.py │ │ ├── iologger.py │ │ ├── logger_utils.py │ │ └── steplogger.py │ │ ├── scripts │ │ ├── __init__.py │ │ ├── executor.py │ │ ├── icolos_workflow.py │ │ ├── sdf2smi.py │ │ └── validator.py │ │ └── utils │ │ ├── __init__.py │ │ ├── constants.py │ │ ├── entry_point_functions │ │ ├── __init__.py │ │ ├── logging_helper_functions.py │ │ └── parsing_functions.py │ │ ├── enums │ │ ├── __init__.py │ │ ├── composite_agents_enums.py │ │ ├── compound_enums.py │ │ ├── entry_points.py │ │ ├── execution_enums.py │ │ ├── flow_control_enums.py │ │ ├── general_utils_enums.py │ │ ├── input_enums.py │ │ ├── logging_enums.py │ │ ├── parallelization.py │ │ ├── program_parameters.py │ │ ├── step_enums.py │ │ ├── step_initialization_enum.py │ │ └── write_out_enums.py │ │ ├── execute_external │ │ ├── __init__.py │ │ ├── autodockvina.py │ │ ├── cresset_executor.py │ │ ├── crest.py │ │ ├── execute.py │ │ ├── fep_plus.py │ │ ├── glide.py │ │ ├── gold.py │ │ ├── gromacs.py │ │ ├── ifd_executor.py │ │ ├── jazzy.py │ │ ├── kallisto.py │ │ ├── license_token_guard.py │ │ ├── ligprep.py │ │ ├── macromodel.py │ │ ├── omega.py │ │ ├── openbabel.py │ │ ├── pmx.py │ │ ├── prime.py │ │ ├── schrodinger.py │ │ ├── sdconvert.py │ │ ├── slurm_executor.py │ │ ├── structcat.py │ │ ├── turbomole.py │ │ └── xtb.py │ │ ├── general │ │ ├── __init__.py │ │ ├── arparse_bool_extension.py │ │ ├── citation_generator.py │ │ ├── convenience_functions.py │ │ ├── files_paths.py │ │ ├── icolos_exceptions.py │ │ ├── molecules.py │ │ ├── parallelization.py │ │ ├── print_log.py │ │ ├── progress_bar.py │ │ └── strings.py │ │ └── smiles.py └── tests │ ├── CREST │ ├── __init__.py │ └── test_CREST_confgen.py │ ├── OMEGA │ ├── __init__.py │ └── test_OMEGA_confgen.py │ ├── Turbomole │ ├── __init__.py │ └── test_Turbomole.py │ ├── XTB │ ├── __init__.py │ └── test_XTB_confgen.py │ ├── __init__.py │ ├── autodockvina │ ├── __init__.py │ ├── test_adv_docking.py │ └── test_adv_target_prep.py │ ├── boltzmann_weighting │ ├── __init__.py │ └── test_boltzmann_weighting.py │ ├── ccdc │ ├── __init__.py │ └── test_gold_docking.py │ ├── clustering │ ├── __init__.py │ └── test_clustering.py │ ├── composite_agents │ ├── __init__.py │ └── test_workflow.py │ ├── containers │ ├── __init__.py │ ├── test_compound.py │ ├── test_generic.py │ └── test_perturbation_map.py │ ├── cosmo │ ├── __init__.py │ └── test_Cosmo.py │ ├── esp_sim │ ├── __init__.py │ └── test_esp_sim.py │ ├── feature_counter │ ├── __init__.py │ └── test_feature_counter.py │ ├── flow_control │ ├── __init__.py │ ├── test_iterator.py │ └── test_slurm_interface.py │ ├── gromacs │ ├── __init__.py │ ├── test_cluster.py │ ├── test_cluster_ts.py │ ├── test_do_dssp.py │ ├── test_editconf.py │ ├── test_genion.py │ ├── test_grompp.py │ ├── test_mdrun.py │ ├── test_mmpbsa.py │ ├── test_pdb2gmx.py │ ├── test_removelig.py │ ├── test_rmsd.py │ ├── test_solvate.py │ ├── test_trjcat.py │ └── test_trjconv.py │ ├── integration_tests │ ├── __init__.py │ ├── test_docking.py │ ├── test_fep_plus.py │ ├── test_gromacs.py │ ├── test_pmx_rbfe.py │ └── test_rmsd_iter.py │ ├── io │ ├── __init__.py │ ├── test_data_manipulation.py │ ├── test_embedder.py │ └── test_initialize_compound.py │ ├── jazzy │ ├── __init__.py │ └── test_jazzy.py │ ├── kallisto │ ├── __init__.py │ └── test_kallisto.py │ ├── lomap │ ├── __init__.py │ └── test_lomap.py │ ├── mdpocket │ ├── __init__.py │ └── test_md_pocket.py │ ├── openff │ ├── __init__.py │ └── test_openff2gmx.py │ ├── panther │ ├── __init__.py │ └── test_panther.py │ ├── pmx │ ├── __init__.py │ ├── test_abfe.py │ ├── test_analyse.py │ ├── test_assemble_systems.py │ ├── test_atomMapping.py │ ├── test_box_water_ions.py │ ├── test_doublebox.py │ ├── test_genlib.py │ ├── test_gentop.py │ ├── test_ligandHybrid.py │ ├── test_mutate.py │ ├── test_prepare_simulations.py │ ├── test_prepare_transitions.py │ ├── test_run_simulations.py │ └── test_setup_workpath.py │ ├── prediction │ ├── __init__.py │ ├── test_active_learning.py │ ├── test_model_building.py │ └── test_predictor.py │ ├── rms_filter │ ├── __init__.py │ └── test_rmsfilter.py │ ├── rmsd │ ├── __init__.py │ └── test_rmsd.py │ ├── schrodinger │ ├── __init__.py │ ├── test_abfe.py │ ├── test_desmond_production.py │ ├── test_desmond_setup.py │ ├── test_fep_analysis.py │ ├── test_fep_plus_execution.py │ ├── test_fep_plus_setup.py │ ├── test_glide.py │ ├── test_ligprep.py │ ├── test_macromodel.py │ ├── test_prepwizard.py │ ├── test_prime.py │ ├── test_protein_interaction.py │ └── test_residue_scanning.py │ ├── shaep │ ├── __init__.py │ └── test_shaep.py │ ├── step_utils │ ├── __init__.py │ ├── test_input_merger.py │ ├── test_input_preparator.py │ ├── test_obabel_converter.py │ ├── test_run_variables_resolver.py │ ├── test_structconvert.py │ └── test_writeout.py │ ├── structure_prediction │ ├── __init__.py │ ├── test_dssp.py │ ├── test_pdb_fixer.py │ └── test_peptide_embedder.py │ └── tests_paths.py ├── reinvent ├── reinvent_scoring │ ├── .gitignore │ ├── Jenkinsfile │ ├── LICENSE │ ├── README.md │ ├── environment.yml │ ├── main_test.py │ ├── pytest.ini │ ├── reinvent_scoring │ │ ├── __init__.py │ │ └── scoring │ │ │ ├── __init__.py │ │ │ ├── component_parameters.py │ │ │ ├── diversity_filters │ │ │ ├── __init__.py │ │ │ ├── curriculum_learning │ │ │ │ ├── __init__.py │ │ │ │ ├── base_diversity_filter.py │ │ │ │ ├── column_names_enum.py │ │ │ │ ├── diversity_filter.py │ │ │ │ ├── diversity_filter_memory.py │ │ │ │ ├── diversity_filter_parameters.py │ │ │ │ ├── identical_murcko_scaffold.py │ │ │ │ ├── identical_topological_scaffold.py │ │ │ │ ├── loggable_data_dto.py │ │ │ │ ├── memory_record_dto.py │ │ │ │ ├── no_filter.py │ │ │ │ ├── no_filter_with_penalty.py │ │ │ │ ├── scaffold_similarity.py │ │ │ │ └── update_diversity_filter_dto.py │ │ │ ├── lib_invent │ │ │ │ ├── __init__.py │ │ │ │ ├── base_diversity_filter.py │ │ │ │ ├── diversity_filter.py │ │ │ │ ├── diversity_filter_memory.py │ │ │ │ ├── diversity_filter_parameters.py │ │ │ │ ├── identical_murcko_scaffold.py │ │ │ │ ├── no_filter.py │ │ │ │ └── no_filter_with_penalty.py │ │ │ ├── molformer │ │ │ │ ├── __init__.py │ │ │ │ ├── diversity_filter.py │ │ │ │ ├── identical_murcko_scaffold.py │ │ │ │ ├── no_filter.py │ │ │ │ └── no_filter_with_penalty.py │ │ │ └── reinvent_core │ │ │ │ ├── __init__.py │ │ │ │ ├── base_diversity_filter.py │ │ │ │ ├── diversity_filter.py │ │ │ │ ├── diversity_filter_memory.py │ │ │ │ ├── diversity_filter_parameters.py │ │ │ │ ├── identical_murcko_scaffold.py │ │ │ │ ├── identical_topological_scaffold.py │ │ │ │ ├── no_scaffold_filter.py │ │ │ │ └── scaffold_similarity.py │ │ │ ├── enums │ │ │ ├── __init__.py │ │ │ ├── active_learning_parameters_enum.py │ │ │ ├── container_type_enum.py │ │ │ ├── descriptor_types_enum.py │ │ │ ├── diversity_filter_enum.py │ │ │ ├── environmental_variables_enum.py │ │ │ ├── logging_mode_enum.py │ │ │ ├── rocs_similarity_measures_enum.py │ │ │ ├── rocs_specific_parameters_enum.py │ │ │ ├── scoring_function_component_enum.py │ │ │ ├── scoring_function_enum.py │ │ │ ├── transformation_parameters_enum.py │ │ │ └── transformation_type_enum.py │ │ │ ├── function │ │ │ ├── __init__.py │ │ │ ├── base_scoring_function.py │ │ │ ├── custom_product.py │ │ │ └── custom_sum.py │ │ │ ├── predictive_model │ │ │ ├── __init__.py │ │ │ ├── base_model_container.py │ │ │ ├── model_container.py │ │ │ ├── optuna_container.py │ │ │ └── scikit_model_container.py │ │ │ ├── score_components │ │ │ ├── __init__.py │ │ │ ├── active_learning │ │ │ │ ├── __init__.py │ │ │ │ ├── active_learning.py │ │ │ │ ├── base_al_component.py │ │ │ │ ├── default_values.py │ │ │ │ └── scripts │ │ │ │ │ ├── __init__.py │ │ │ │ │ ├── acquisition_functions.py │ │ │ │ │ ├── molecular_representations.py │ │ │ │ │ ├── oracles.py │ │ │ │ │ ├── retrospectiveReinvent.py │ │ │ │ │ └── surrogate_models.py │ │ │ ├── aizynth │ │ │ │ ├── __init__.py │ │ │ │ ├── aizynth_cli_api.py │ │ │ │ ├── building_block_availability_component.py │ │ │ │ ├── parameters.py │ │ │ │ └── util.py │ │ │ ├── base_score_component.py │ │ │ ├── console_invoked │ │ │ │ ├── base_console_invoked_component.py │ │ │ │ ├── external_process.py │ │ │ │ ├── icolos.py │ │ │ │ └── mmp │ │ │ │ │ ├── __init__.py │ │ │ │ │ ├── mmp_parameter_dto.py │ │ │ │ │ └── mmpdb_parameter_dto.py │ │ │ ├── link_invent │ │ │ │ ├── __init__.py │ │ │ │ ├── base_link_invent_component.py │ │ │ │ ├── linker_effective_length.py │ │ │ │ ├── linker_graph_length.py │ │ │ │ ├── linker_length_ratio.py │ │ │ │ ├── linker_mol_weight.py │ │ │ │ ├── linker_num_aliphatic_rings.py │ │ │ │ ├── linker_num_aromatic_rings.py │ │ │ │ ├── linker_num_hba.py │ │ │ │ ├── linker_num_hbd.py │ │ │ │ ├── linker_num_rings.py │ │ │ │ ├── linker_num_sp2_atoms.py │ │ │ │ ├── linker_num_sp3_atoms.py │ │ │ │ ├── linker_num_sp_atoms.py │ │ │ │ └── linker_ratio_rotatable_bonds.py │ │ │ ├── physchem │ │ │ │ ├── __init__.py │ │ │ │ ├── base_physchem_component.py │ │ │ │ ├── graph_length.py │ │ │ │ ├── hba.py │ │ │ │ ├── hbd.py │ │ │ │ ├── mol_weight.py │ │ │ │ ├── num_aliphatic_rings.py │ │ │ │ ├── num_aromatic_rings.py │ │ │ │ ├── num_rings.py │ │ │ │ ├── number_of_stereo_centers.py │ │ │ │ ├── rot_bonds.py │ │ │ │ ├── slogp.py │ │ │ │ └── tpsa.py │ │ │ ├── rocs │ │ │ │ ├── __init__.py │ │ │ │ ├── base_rocs_component.py │ │ │ │ ├── default_values.py │ │ │ │ ├── oefuncs.py │ │ │ │ ├── oehelper.py │ │ │ │ ├── parallel_rocs_similarity.py │ │ │ │ └── rocs_similarity.py │ │ │ ├── score_component_factory.py │ │ │ ├── standard │ │ │ │ ├── __init__.py │ │ │ │ ├── chemprop_component.py │ │ │ │ ├── custom_alerts_component.py │ │ │ │ ├── group_count.py │ │ │ │ ├── jaccard_distance.py │ │ │ │ ├── matching_substructure.py │ │ │ │ ├── predictive_property_component.py │ │ │ │ ├── qed_score.py │ │ │ │ ├── selectivity_component.py │ │ │ │ └── tanimoto_similarity.py │ │ │ ├── structural │ │ │ │ ├── __init__.py │ │ │ │ ├── azdock.py │ │ │ │ ├── base_structural_component.py │ │ │ │ └── dockstream.py │ │ │ └── synthetic_accessibility │ │ │ │ ├── __init__.py │ │ │ │ ├── fpscores.pkl.gz │ │ │ │ ├── sas_component.py │ │ │ │ └── sascorer.py │ │ │ ├── score_summary.py │ │ │ ├── score_transformations.py │ │ │ ├── scoring_function_factory.py │ │ │ ├── scoring_function_parameters.py │ │ │ └── utils.py │ ├── setup.py │ └── unittest_reinvent │ │ ├── diversity_filter_tests │ │ ├── __init__.py │ │ ├── fixtures.py │ │ ├── test_diversity_filter_memory.py │ │ ├── test_diversity_filter_memory_base.py │ │ ├── test_diversity_filter_memory_update.py │ │ ├── test_murcko_scaffold_base.py │ │ ├── test_murcko_scaffold_bucket_full_penalty.py │ │ ├── test_murcko_scaffold_filtering.py │ │ ├── test_murcko_scaffold_invalid_smile_protection.py │ │ ├── test_murcko_scaffold_memory_size.py │ │ ├── test_murcko_scaffold_output_scores.py │ │ ├── test_murcko_scaffold_score_threshold.py │ │ ├── test_murcko_scaffold_superfluous_addition.py │ │ ├── test_murcko_scaffold_valid_addition.py │ │ ├── test_no_filter_invalid_smile_protection.py │ │ ├── test_no_filter_memory_size.py │ │ ├── test_no_filter_output_scores.py │ │ ├── test_no_filter_superfluous_addition.py │ │ ├── test_no_filter_valid_addition.py │ │ ├── test_scaffold_similarity_filter_invalid_smile_protection.py │ │ ├── test_scaffold_similarity_filter_memory_set.py │ │ ├── test_scaffold_similarity_filter_similarity_filtering.py │ │ ├── test_scaffold_similarity_filter_superfluous_addition.py │ │ ├── test_scaffold_similarity_filter_valid_addition.py │ │ ├── test_tanimoto_similarity_base.py │ │ ├── test_topological_scaffold_filter_base.py │ │ ├── test_topological_scaffold_filter_bucket_full_penalty.py │ │ ├── test_topological_scaffold_filter_invalid_smile_protection.py │ │ ├── test_topological_scaffold_filter_memory_size.py │ │ ├── test_topological_scaffold_filter_output_scores.py │ │ ├── test_topological_scaffold_filter_scaffold_filtering.py │ │ ├── test_topological_scaffold_filter_score_threshold.py │ │ ├── test_topological_scaffold_filter_superfluous_addition.py │ │ └── test_topological_scaffold_filter_valid_addition.py │ │ ├── fixtures │ │ ├── dummy_classification_model.pkl │ │ ├── dummy_regression_model.pkl │ │ ├── test_config.py │ │ └── test_data.py │ │ ├── scoring_tests │ │ ├── __init__.py │ │ ├── console_invoked │ │ │ ├── test_icolos.py │ │ │ └── test_mmp.py │ │ ├── fixtures │ │ │ ├── __init__.py │ │ │ ├── azdock_data │ │ │ │ ├── azdock_OpenEye.json │ │ │ │ ├── azdock_OpenEye_receptor.oeb │ │ │ │ └── azdock_ligand_PU8.sdf │ │ │ ├── azgard_data │ │ │ │ ├── azgard_NIBR.json │ │ │ │ ├── azgard_NIBR_negative_image.mol2 │ │ │ │ └── azgard_cox2_grid.zip │ │ │ ├── chemprop_models │ │ │ │ └── model.pt │ │ │ ├── dockstream_data │ │ │ │ ├── dockstream_OpenEye.json │ │ │ │ ├── dockstream_OpenEye_receptor.oeb │ │ │ │ └── dockstream_ligand_PU8.sdf │ │ │ └── icolos_data │ │ │ │ ├── icolos_NIBR.json │ │ │ │ ├── icolos_NIBR_negative_image.mol2 │ │ │ │ └── icolos_cox2_grid.zip │ │ ├── link_invent │ │ │ ├── __init__.py │ │ │ ├── test_linker_effective_length_score_no_transformation.py │ │ │ ├── test_linker_effective_length_score_with_double_sigmoid.py │ │ │ ├── test_linker_graph_length_score_no_transformation.py │ │ │ ├── test_linker_graph_length_score_with_double_sigmoid.py │ │ │ ├── test_linker_length_ratio_score_no_transformation.py │ │ │ ├── test_linker_length_ratio_score_with_double_sigmoid.py │ │ │ ├── test_linker_mol_weight_with_double_sigmoid.py │ │ │ ├── test_linker_num_aliphatic_rings_with_step.py │ │ │ ├── test_linker_num_aromatic_rings_with_step.py │ │ │ ├── test_linker_num_hba_with_double_sigmoid.py │ │ │ ├── test_linker_num_hbd_with_step.py │ │ │ ├── test_linker_num_rings_with_step.py │ │ │ ├── test_linker_num_sp2_atoms_no_transformation.py │ │ │ ├── test_linker_num_sp3_atoms_no_transformation.py │ │ │ ├── test_linker_num_sp_atoms_no_transformation.py │ │ │ └── test_linker_ratio_rotatable_bonds_no_transformation.py │ │ ├── physchem │ │ │ ├── __init__.py │ │ │ ├── base_setup.py │ │ │ ├── test_graph_length_score_no_transformation.py │ │ │ ├── test_graph_length_score_with_double_sigmoid.py │ │ │ ├── test_hba_lipinski_score_no_transformation.py │ │ │ ├── test_hba_lipinski_score_with_double_sigmoid.py │ │ │ ├── test_hbd_lipinski_score_no_transformation.py │ │ │ ├── test_hbd_lipinski_score_with_double_sigmoid.py │ │ │ ├── test_mw_score_no_transformation.py │ │ │ ├── test_mw_score_with_double_sigmoid.py │ │ │ ├── test_num_aliphatic_rings.py │ │ │ ├── test_num_aromatic_rings.py │ │ │ ├── test_num_rings_score_no_transformation.py │ │ │ ├── test_num_rings_score_with_double_sigmoid.py │ │ │ ├── test_num_rot_bonds_score_no_transformation.py │ │ │ ├── test_num_rot_bonds_score_with_double_sigmoid.py │ │ │ ├── test_number_of_stereo_centers.py │ │ │ ├── test_slogp_score_no_transformation.py │ │ │ ├── test_slogp_score_with_double_sigmoid.py │ │ │ ├── test_tpsa_score_no_transformation.py │ │ │ └── test_tpsa_score_with_double_sigmoid.py │ │ ├── scoring_3d │ │ │ ├── __init__.py │ │ │ ├── fixtures.py │ │ │ ├── test_large_batch_scoring_parallel_rocs_similarity.py │ │ │ ├── test_parallel_rocs_multi_similarity.py │ │ │ ├── test_parallel_rocs_similarity.py │ │ │ ├── test_parallel_rocs_similarity_enumerate_stereo.py │ │ │ ├── test_parallel_rocs_similarity_negative_volume.py │ │ │ ├── test_parallel_rocs_similarity_omegaopts.py │ │ │ ├── test_parallel_rocs_similarity_tautomers.py │ │ │ ├── test_parallel_rocs_similarity_tversky_score_bug.py │ │ │ ├── test_parallel_rocs_similarity_with_custom_cff.py │ │ │ ├── test_parallel_rocs_similarity_with_shape_query_no_transf_kw.py │ │ │ ├── test_parallel_rocs_similarity_with_shape_query_save_overlays.py │ │ │ ├── test_parallel_rocs_similarity_with_transformation.py │ │ │ ├── test_parallel_rocs_similarity_with_two_components.py │ │ │ ├── test_rocs_multi_similarity.py │ │ │ ├── test_rocs_similarity.py │ │ │ ├── test_rocs_similarity_tversky_score_bug.py │ │ │ ├── test_rocs_similarity_with_custom_cff.py │ │ │ ├── test_rocs_similarity_with_shape_query_no_trans_kw.py │ │ │ ├── test_rocs_similarity_with_transformation.py │ │ │ └── test_rocs_similarity_with_two_components.py │ │ ├── scoring_components │ │ │ ├── __init__.py │ │ │ ├── aizynth │ │ │ │ └── test_building_block_availability.py │ │ │ ├── base_matching_substructure.py │ │ │ ├── base_predictive_property_component.py │ │ │ ├── base_selectivity_component.py │ │ │ ├── fixtures.py │ │ │ ├── test_broken_regression_selectivity_component.py │ │ │ ├── test_chem_prop.py │ │ │ ├── test_classification_selectivity_component.py │ │ │ ├── test_custom_alerts_default_alerts.py │ │ │ ├── test_custom_alerts_user_alerts.py │ │ │ ├── test_group_count_component.py │ │ │ ├── test_invalid_matching_substructure.py │ │ │ ├── test_jaccard_distance.py │ │ │ ├── test_jaccard_distance_custom_fingerprint_parameters.py │ │ │ ├── test_matching_substructure.py │ │ │ ├── test_matching_substructures_not_provided.py │ │ │ ├── test_mixed_selectivity_component.py │ │ │ ├── test_predictive_property_component.py │ │ │ ├── test_predictive_property_component_mols.py │ │ │ ├── test_predictive_property_component_smiles.py │ │ │ ├── test_qed_score.py │ │ │ ├── test_regression_selectivity_component.py │ │ │ ├── test_tanimoto_custom_fingerprint_parameters.py │ │ │ └── test_tanimoto_similarity.py │ │ ├── scoring_functions │ │ │ ├── __init__.py │ │ │ ├── base_test_custom_sum.py │ │ │ ├── base_test_primary_multiplicative.py │ │ │ ├── base_test_selectivity_double_sigmoid.py │ │ │ ├── base_test_selectivity_multiplicative.py │ │ │ ├── test_custom_sum.py │ │ │ ├── test_custom_sum_alerts_with_user_alerts.py │ │ │ ├── test_custom_sum_combined_distance_and_similarity.py │ │ │ ├── test_custom_sum_custom_alerts_with_default_alerts.py │ │ │ ├── test_custom_sum_invalid_matching_substructure.py │ │ │ ├── test_custom_sum_jaccard_distance.py │ │ │ ├── test_custom_sum_matching_substructure.py │ │ │ ├── test_custom_sum_matching_substructure_not_provided.py │ │ │ ├── test_custom_sum_qed_score.py │ │ │ ├── test_custom_sum_tanimoto_similarity.py │ │ │ ├── test_desirability_multiplicative_function.py │ │ │ ├── test_parallel_additive.py │ │ │ ├── test_parallel_primary_multiplicative.py │ │ │ ├── test_parallel_product.py │ │ │ ├── test_parallel_scoring_function_factory.py │ │ │ ├── test_parallel_selectivity_multiplicative.py │ │ │ ├── test_primary_mult_with_alert_no_sigm_trans.py │ │ │ ├── test_primary_mult_with_no_activity.py │ │ │ ├── test_primary_mult_with_prediction_classification_and_regression.py │ │ │ ├── test_primary_multiplicative_function.py │ │ │ ├── test_primary_multiplicative_with_alert.py │ │ │ ├── test_primary_multiplicative_with_desirability_component.py │ │ │ ├── test_product.py │ │ │ ├── test_scoring_function_factory.py │ │ │ ├── test_selectivity_function_with_double_sigmoid.py │ │ │ ├── test_selectivity_multiplicative_function.py │ │ │ ├── test_selectivity_multiplicative_function_with_predictive_property.py │ │ │ ├── test_selectivity_multiplicative_function_with_predictive_property_and_alert.py │ │ │ ├── test_selectivity_multiplicative_function_with_predictive_property_no_sigm_trans.py │ │ │ └── test_special_desirability_multiplicative_function.py │ │ ├── scoring_transformations │ │ │ ├── __init__.py │ │ │ ├── base_test_score_sigmoid_transformations.py │ │ │ ├── base_test_score_transformations.py │ │ │ ├── fixtures.py │ │ │ ├── test_score_custom_interpolation.py │ │ │ ├── test_score_double_sigmoid_transformation.py │ │ │ ├── test_score_invalid_transformation.py │ │ │ ├── test_score_left_step_transformation.py │ │ │ ├── test_score_no_transformation.py │ │ │ ├── test_score_reverse_sigmoid_transformation.py │ │ │ ├── test_score_right_step_transformation.py │ │ │ ├── test_score_sigmoid_transformation.py │ │ │ └── test_score_step_transformation.py │ │ ├── structural │ │ │ ├── __init__.py │ │ │ ├── test_azdock.py │ │ │ └── test_dockstream.py │ │ └── synthetic_accessibility │ │ │ ├── __init__.py │ │ │ └── test_sas_component.py │ │ └── unit_testing.py └── reinventcli │ ├── .dockerignore │ ├── .gitignore │ ├── Dockerfile │ ├── README.md │ ├── README_internal.md │ ├── __init__.py │ ├── build │ ├── Jenkinsfile │ └── agent-pod.yaml │ ├── configs │ └── sample_inputs │ │ ├── auto_cl.json │ │ ├── azdock_rf.json │ │ ├── create_model.v2.json │ │ ├── curriculum_learning.json │ │ ├── curriculum_learning_updated.json │ │ ├── input.slurm.v2.sh │ │ ├── lib_invent_rl.json │ │ ├── link_invent.json │ │ ├── link_invent_create_model.json │ │ ├── molformer_create_model.json │ │ ├── molformer_create_model_ranking.json │ │ ├── molformer_transfer_learning.json │ │ ├── molformer_transfer_learning_ranking.json │ │ ├── reinforcement_learning.v2.json │ │ ├── reinforcement_learning.v2_custom_fingerprint.json │ │ ├── reinforcement_learning_pm.v2.json │ │ ├── reinforcement_learning_sm.v2.json │ │ ├── rocs_input.v2.json │ │ ├── rocs_input.v2.slurm │ │ ├── sa_score_component.json │ │ ├── sampling.v2.json │ │ ├── sampling_molformer.json │ │ ├── scoring_runner.v2.json │ │ ├── selectivity_component.json │ │ ├── transfer_learning.v2.json │ │ └── validation.v2.json │ ├── input.py │ ├── main_test.py │ ├── pytest.ini │ ├── reinvent.yml │ ├── running_modes │ ├── __init__.py │ ├── automated_curriculum_learning │ │ ├── __init__.py │ │ ├── actions │ │ │ ├── __init__.py │ │ │ ├── base_action.py │ │ │ ├── base_sample_action.py │ │ │ ├── lib_invent_sample_model.py │ │ │ ├── link_invent_sample_model.py │ │ │ ├── molformer_sample_model.py │ │ │ └── reinvent_sample_model.py │ │ ├── automated_curriculum_runner.py │ │ ├── curriculum_strategy │ │ │ ├── __init__.py │ │ │ ├── base_curriculum_strategy.py │ │ │ ├── curriculum_strategy.py │ │ │ ├── linkinvent_curriculum_strategy.py │ │ │ ├── molformer_curriculum_strategy.py │ │ │ ├── no_curriculum_strategy.py │ │ │ └── reinvent_curriculum_strategy.py │ │ ├── dto │ │ │ ├── __init__.py │ │ │ ├── curriculum_outcome_dto.py │ │ │ ├── sampled_batch_dto.py │ │ │ ├── sampled_sequences_dto.py │ │ │ ├── timestep_dto.py │ │ │ └── updated_likelihoods_dto.py │ │ ├── inception │ │ │ ├── __init__.py │ │ │ └── inception.py │ │ ├── learning_strategy │ │ │ ├── __init__.py │ │ │ ├── base_double_query_learning_strategy.py │ │ │ ├── base_learning_strategy.py │ │ │ ├── base_linker_strategy.py │ │ │ ├── base_single_query_learning_strategy.py │ │ │ ├── dap_molformer_strategy.py │ │ │ ├── dap_single_query_strategy.py │ │ │ ├── dap_strategy.py │ │ │ ├── learning_strategy.py │ │ │ ├── learning_strategy_configuration.py │ │ │ ├── learning_strategy_enum.py │ │ │ ├── mascof_strategy.py │ │ │ ├── mauli_strategy.py │ │ │ └── sdap_strategy.py │ │ ├── logging │ │ │ ├── __init__.py │ │ │ ├── auto_cl_logger.py │ │ │ ├── base_logger.py │ │ │ ├── console_message.py │ │ │ ├── local_logger.py │ │ │ └── remote_logger.py │ │ └── production_strategy │ │ │ ├── base_production_strategy.py │ │ │ ├── link_invent_production_strategy.py │ │ │ ├── molformer_production_strategy.py │ │ │ ├── production_strategy.py │ │ │ └── reinvent_production_strategy.py │ ├── configurations │ │ ├── __init__.py │ │ ├── automated_curriculum_learning │ │ │ ├── __init__.py │ │ │ ├── automated_curriculum_learning_configuration.py │ │ │ ├── automated_curriculum_learning_input_configuration.py │ │ │ ├── automated_curriculum_learning_linkinvent_configuration.py │ │ │ ├── base_configuration.py │ │ │ ├── curriculum_objective.py │ │ │ ├── curriculum_strategy_configuration.py │ │ │ ├── curriculum_strategy_input_configuration.py │ │ │ ├── inception_configuration.py │ │ │ ├── linkinvent_curriculum_strategy_configuration.py │ │ │ ├── linkinvent_production_strategy_configuration.py │ │ │ ├── prodcution_strategy_input_configuration.py │ │ │ └── production_strategy_configuration.py │ │ ├── compound_sampling │ │ │ ├── __init__.py │ │ │ ├── multinomial_sampling_configuration.py │ │ │ └── sample_from_model_configuration.py │ │ ├── create_model │ │ │ ├── __init__.py │ │ │ ├── create_model_configuration.py │ │ │ ├── link_invent_create_model_configuration.py │ │ │ └── molformer_create_model_configuration.py │ │ ├── curriculum_learning │ │ │ ├── __init__.py │ │ │ ├── curriculum_learning_components.py │ │ │ └── curriculum_learning_configuration.py │ │ ├── general_configuration_envelope.py │ │ ├── logging │ │ │ ├── __init__.py │ │ │ ├── base_log_config.py │ │ │ ├── create_model_log_configuration.py │ │ │ ├── curriculum_log_configuration.py │ │ │ ├── reinforcement_log_configuration.py │ │ │ ├── remote_logging.py │ │ │ ├── sampling_log_configuration.py │ │ │ ├── scoring_log_configuration.py │ │ │ └── transfer_learning_log_configuration.py │ │ ├── reinforcement_learning │ │ │ ├── __init__.py │ │ │ ├── inception_configuration.py │ │ │ ├── reinforcement_learning_components.py │ │ │ └── reinforcement_learning_configuration.py │ │ ├── scoring │ │ │ ├── __init__.py │ │ │ ├── scoring_runner_components.py │ │ │ └── scoring_runner_configuration.py │ │ └── transfer_learning │ │ │ ├── __init__.py │ │ │ ├── adaptive_learning_rate_configuration.py │ │ │ ├── link_invent_learning_rate_configuration.py │ │ │ ├── link_invent_transfer_learning_configuration.py │ │ │ ├── molformer_transfer_learning_configuration.py │ │ │ ├── noamopt_configuration.py │ │ │ └── transfer_learning_configuration.py │ ├── constructors │ │ ├── __init__.py │ │ ├── base_running_mode.py │ │ ├── create_model_mode_constructor.py │ │ ├── curriculum_learning_mode_constructor.py │ │ ├── reinforcement_learning_mode_constructor.py │ │ ├── running_mode.py │ │ ├── sampling_mode_constructor.py │ │ ├── scoring_mode_constructor.py │ │ ├── transfer_learning_mode_constructor.py │ │ └── validation_mode_constructor.py │ ├── create_model │ │ ├── __init__.py │ │ ├── create_model.py │ │ ├── link_invent_create_model.py │ │ ├── logging │ │ │ ├── __init__.py │ │ │ ├── base_create_model_logger.py │ │ │ ├── create_model_logger.py │ │ │ ├── local_create_model_logger.py │ │ │ └── remote_create_model_logger.py │ │ └── molformer_create_model.py │ ├── curriculum_learning │ │ ├── curriculum_runner.py │ │ ├── logging │ │ │ ├── __init__.py │ │ │ ├── base_curriculum_logger.py │ │ │ ├── curriculum_logger.py │ │ │ ├── local_curriculum_logger.py │ │ │ └── remote_curriculum_logger.py │ │ └── update_watcher.py │ ├── enums │ │ ├── __init__.py │ │ ├── adaptive_learning_rate_enum.py │ │ ├── curriculum_strategy_enum.py │ │ ├── curriculum_type_enum.py │ │ ├── logging_mode_enum.py │ │ ├── merging_strategy_enum.py │ │ ├── model_type_enum.py │ │ ├── production_strategy_enum.py │ │ ├── ranking_strategy_enum.py │ │ ├── running_mode_enum.py │ │ ├── scoring_runner_enum.py │ │ └── scoring_table_enum.py │ ├── manager.py │ ├── reinforcement_learning │ │ ├── __init__.py │ │ ├── actions │ │ │ ├── __init__.py │ │ │ ├── base_action.py │ │ │ ├── lib_invent_likelihood_evaluation.py │ │ │ ├── lib_invent_sample_model.py │ │ │ ├── link_invent_likelihood_evaluation.py │ │ │ └── link_invent_sample_model.py │ │ ├── configurations │ │ │ ├── __init__.py │ │ │ ├── learning_strategy_configuration.py │ │ │ ├── lib_invent_reinforcement_learning_configuration.py │ │ │ ├── lib_invent_scoring_strategy_configuration.py │ │ │ ├── link_invent_log_configuration.py │ │ │ ├── link_invent_reinforcement_learning_configuration.py │ │ │ ├── link_invent_scoring_strategy_congfiguration.py │ │ │ └── scoring_strategy_configuration.py │ │ ├── core_reinforcement_learning.py │ │ ├── dto │ │ │ ├── __init__.py │ │ │ └── sampled_sequences_dto.py │ │ ├── inception.py │ │ ├── learning_strategy │ │ │ ├── __init__.py │ │ │ ├── base_learning_strategy.py │ │ │ ├── dap_strategy.py │ │ │ ├── learning_strategy.py │ │ │ ├── learning_strategy_enum.py │ │ │ ├── mascof_strategy.py │ │ │ ├── mauli_strategy.py │ │ │ └── sdap_strategy.py │ │ ├── lib_invent_reinforcement_learning.py │ │ ├── link_invent_reinforcement_learning.py │ │ ├── logging │ │ │ ├── __init__.py │ │ │ ├── base_reinforcement_logger.py │ │ │ ├── console_message.py │ │ │ ├── link_logging │ │ │ │ ├── __init__.py │ │ │ │ ├── base_reinforcement_logger.py │ │ │ │ ├── bond_link_reinforcement_logger.py │ │ │ │ ├── console_message.py │ │ │ │ ├── local_bond_link_reinforcement_logger.py │ │ │ │ └── remote_bond_link_reinforcement_logger.py │ │ │ ├── local_reinforcement_logger.py │ │ │ ├── reinforcement_logger.py │ │ │ └── remote_reinforcement_logger.py │ │ ├── margin_guard.py │ │ └── scoring_strategy │ │ │ ├── __init__.py │ │ │ ├── base_scoring_strategy.py │ │ │ ├── lib_invent_scoring_strategy.py │ │ │ ├── link_invent_scoring_strategy.py │ │ │ ├── scoring_strategy.py │ │ │ └── scoring_strategy_enum.py │ ├── sampling │ │ ├── __init__.py │ │ ├── logging │ │ │ ├── __init__.py │ │ │ ├── base_sampling_logger.py │ │ │ ├── local_sampling_logger.py │ │ │ ├── remote_sampling_logger.py │ │ │ └── sampling_logger.py │ │ ├── sample_from_model.py │ │ └── sample_from_molformer.py │ ├── scoring │ │ ├── __init__.py │ │ ├── logging │ │ │ ├── __init__.py │ │ │ ├── base_scoring_logger.py │ │ │ ├── local_scoring_logger.py │ │ │ ├── remote_scoring_logger.py │ │ │ └── scoring_logger.py │ │ └── scoring_runner.py │ ├── transfer_learning │ │ ├── __init__.py │ │ ├── adaptive_learning_rate.py │ │ ├── dto │ │ │ ├── __init__.py │ │ │ ├── collected_stats_dto.py │ │ │ └── sampled_stats_dto.py │ │ ├── link_invent_actions │ │ │ ├── __init__.py │ │ │ ├── base_action.py │ │ │ ├── collect_stats.py │ │ │ └── train_epoch.py │ │ ├── link_invent_transfer_learning_runner.py │ │ ├── logging │ │ │ ├── __init__.py │ │ │ ├── base_transfer_learning_logger.py │ │ │ ├── local_link_invent_transfer_learning_logger.py │ │ │ ├── local_transfer_learning_logger.py │ │ │ ├── remote_transfer_learning_logger.py │ │ │ └── transfer_learning_logger.py │ │ ├── molformer_transfer_learning_runner.py │ │ ├── optimizers │ │ │ ├── __init__.py │ │ │ └── noam.py │ │ └── transfer_learning_runner.py │ ├── utils │ │ ├── __init__.py │ │ ├── configuration.py │ │ ├── general.py │ │ └── plot.py │ └── validation │ │ ├── __init__.py │ │ ├── logging │ │ ├── __init__.py │ │ ├── base_validation_logger.py │ │ ├── local_validation_logger.py │ │ ├── remote_validation_logger.py │ │ └── validation_logger.py │ │ └── validation_runner.py │ ├── sonar-project.properties │ └── unittest_reinvent │ ├── __init__.py │ ├── fixtures │ ├── __init__.py │ ├── dummy_regression_model.pkl │ ├── example.config.json │ ├── predictive_model_fixtures.py │ ├── test_config.py │ ├── test_data.py │ └── utils.py │ └── running_modes │ ├── __init__.py │ ├── create_model_tests │ ├── __init__.py │ ├── test_create_model.py │ ├── test_link_invent_create_model.py │ └── test_molformer_create_model.py │ ├── curriculum_tests │ ├── __init__.py │ ├── test_automated_curriculum_learning.py │ ├── test_manual_curriculum_learning.py │ ├── test_molformer_curriculum_learning.py │ └── test_no_curriculum_molformer.py │ ├── inception_tests │ ├── __init__.py │ ├── test_add.py │ ├── test_add_base.py │ ├── test_add_jaccard_distance.py │ ├── test_empty_add.py │ ├── test_empty_base.py │ ├── test_empty_eval_add_tanimoto.py │ └── test_eval_add_tanimoto.py │ ├── lib_invent_tests │ ├── __init__.py │ ├── learning_strategy_tests │ │ ├── __init__.py │ │ ├── base_learning_strategy.py │ │ ├── test_learning_strategy_dap_strategy.py │ │ ├── test_learning_strategy_mascof_strategy.py │ │ ├── test_learning_strategy_mauli_strategy.py │ │ └── test_learning_strategy_sdap_strategy.py │ ├── logger_tests │ │ ├── __init__.py │ │ └── test_reinforcement_logger.py │ ├── reinforcement_learning_tests │ │ ├── __init__.py │ │ ├── test_reinforcement_learning_likelihood_evaluation.py │ │ └── test_reinforcement_learning_model.py │ └── scoring_strategy_tests │ │ ├── __init__.py │ │ └── test_standard_scoring_strategy_no_reaction_filter.py │ ├── local_logger_tests │ ├── __init__.py │ ├── test_sampling_invalid_smiles.py │ └── test_transfer_logger.py │ ├── model_validation_tests │ ├── __init__.py │ └── test_model_validation.py │ ├── reinforcement_tests │ ├── __init__.py │ ├── test_link_invent_reinforcement_learning_runner.py │ ├── test_margin_guard.py │ ├── test_margin_guard_adjust_guard.py │ ├── test_margin_guard_adjust_guard_on_empty.py │ ├── test_margin_guard_increase_sigma.py │ ├── test_margin_guard_mean_stats.py │ ├── test_margin_guard_threshold.py │ └── test_reinforce_tanimoto_similarity.py │ ├── sample_model_tests │ ├── __init__.py │ ├── test_sample_from_model.py │ └── test_sample_from_molformer.py │ ├── scoring_runner_tests │ ├── __init__.py │ └── test_scoring_runner.py │ └── transfer_learning_tests │ ├── __init__.py │ ├── test_link_invent_transfer_learning.py │ ├── test_molformer_transfer_learning.py │ └── test_transfer_learning.py └── scripts └── rocs_scoring.py /configs/bash_script.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -l 2 | 3 | source rl-al-repo/miniconda3/bin/activate reinvent.v3.2 4 | rl-al-repo/miniconda3/envs/reinvent.v3.2/bin/python rl-al-repo/reinvent/reinventcli/input.py reinvent.json 5 | 6 | -------------------------------------------------------------------------------- /configs/cleanup_script.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -l 2 | 3 | read -p "Are you sure? " -n 1 -r 4 | echo #(optional) move to a new line 5 | 6 | if [[ $REPLY =~ ^[Yy]$ ]] 7 | then 8 | # do dangerous stuff 9 | 10 | rm *.err 11 | rm *.out 12 | rm *.log 13 | rm *.sdf 14 | rm *.csv 15 | rm -r *compounds 16 | rm -r *Compounds 17 | rm -r *CheckPoints 18 | rm JSON 19 | rm docking_counter.txt 20 | rm *.check 21 | 22 | rm test_ligand.sq 23 | rm -r reinvent_results 24 | rm -r ROCS_JSON 25 | rm -r ROCS_CSV 26 | rm -r ROCS_SDF 27 | rm -r saved_states 28 | rm -r reinvent_logging 29 | rm -r docked_files 30 | rm -r output 31 | rm -r reinventBatch 32 | rm -r surrogateCheckpoints 33 | rm -r virtualLibrary 34 | 35 | fi 36 | -------------------------------------------------------------------------------- /data/CoX2/shape_query/S58.sq: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/data/CoX2/shape_query/S58.sq -------------------------------------------------------------------------------- /data/RXRa/minimised/vina_config.txt: -------------------------------------------------------------------------------- 1 | center_x = -3.158 2 | center_y = -18.386 3 | center_z = 31.513 4 | size_x = 20.0 5 | size_y = 20.0 6 | size_z = 20.0 -------------------------------------------------------------------------------- /data/RXRa/vina_config.txt: -------------------------------------------------------------------------------- 1 | receptor = /RXRa/minimised/2p1t_apo_explicitH_minimised.pdbqt 2 | 3 | center_x = -3.158 4 | center_y = -18.386 5 | center_z = 31.513 6 | size_x = 20.0 7 | size_y = 20.0 8 | size_z = 20.0 -------------------------------------------------------------------------------- /data/reinvent_prior/random.prior.new: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/data/reinvent_prior/random.prior.new -------------------------------------------------------------------------------- /icolos/.gitignore: -------------------------------------------------------------------------------- 1 | __pycache__ 2 | pip-wheel-metadata 3 | *.pyc 4 | package.json 5 | .vscode 6 | tags 7 | .idea 8 | *egg-info 9 | dist 10 | 11 | timer.dat 12 | git-commands.txt 13 | 14 | 15 | tests/junk 16 | *.log 17 | .directory 18 | *_cache 19 | *.ipynb_checkpoints 20 | output 21 | config.json 22 | build 23 | docs/_build/doctrees 24 | {entrypoint_dir} 25 | -------------------------------------------------------------------------------- /icolos/environment_min.yml: -------------------------------------------------------------------------------- 1 | name: icolos 2 | channels: 3 | - psi4 4 | - conda-forge 5 | - defaults 6 | - rdkit 7 | - pytorch 8 | dependencies: 9 | - biopython>=1.79 10 | - ipython 11 | - ipykernel 12 | - pip 13 | - python>=3.9 14 | - scikit-learn>=1.0.1 15 | - modal>=0.4 16 | - psi4>=1.4 17 | - pdbfixer 18 | - pydantic>=1.8 19 | - jsonschema 20 | - pyvis 21 | - requests 22 | - openbabel>=3 23 | - rdkit>=2021.09.2 24 | - acpype>=2022 25 | - openff-toolkit>=0.10.2 26 | - dill>=0.3.4 27 | - lomap2>=2.0.0 28 | - pygraphviz 29 | - pytorch 30 | - pip: 31 | - black 32 | - regex 33 | - peptidebuilder>=1.1 34 | - pytest 35 | - pytest-xdist 36 | - skorch>=0.11 37 | -------------------------------------------------------------------------------- /icolos/examples/hpc_script/NIBR_reinvent.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -l 2 | #SBATCH -N 1 3 | #SBATCH -t 0-02:59:00 4 | #SBATCH -p core 5 | #SBATCH --ntasks-per-node=5 6 | #SBATCH --mem-per-cpu=2G 7 | 8 | 9 | 10 | --global_variables "entrypoint_dir:/icolos, input_path_json:{entrypoint_dir}/tests/data/reinvent/small_input.json, output_path_json:{entrypoint_dir}/tests/junk/nibr_reinvent.json" 11 | 12 | -------------------------------------------------------------------------------- /icolos/examples/hpc_script/REINVENT_script.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -l 2 | #SBATCH -N 1 3 | #SBATCH -c 16 4 | #SBATCH --mem=28G 5 | #SBATCH --time=346:0:0 6 | #SBATCH -p gpu 7 | #SBATCH --gres=gpu:1 8 | #SBATCH --output=%j.out 9 | #SBATCH --error=%j.err 10 | 11 | -------------------------------------------------------------------------------- /icolos/examples/hpc_script/SLURM_script.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -l 2 | #SBATCH -N 1 3 | #SBATCH -t 0-02:59:00 4 | #SBATCH -p core 5 | #SBATCH --ntasks-per-node=5 6 | #SBATCH --mem-per-cpu=2G 7 | 8 | 9 | 10 | --global_variables "output_dir:/icolos/tests/junk" -debug 11 | 12 | -------------------------------------------------------------------------------- /icolos/examples/workflow/reinvent/icolos_component.json: -------------------------------------------------------------------------------- 1 | ### add as scoring function component to REINVENT v3.0 or later 2 | 3 | { 4 | "component_type": "icolos", 5 | "name": "Docking", 6 | "weight": 5, 7 | "specific_parameters": { 8 | "transformation": { 9 | "transformation_type": "reverse_sigmoid", 10 | "high": -7.5, 11 | "low": -12.5, 12 | "k": 0.2 13 | }, 14 | "debug": true, 15 | "values_key": "docking_score", 16 | 17 | 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /icolos/external_documentation/REINVENT_input.json: -------------------------------------------------------------------------------- 1 | { 2 | "names": ["0", "1", "3"], 3 | "smiles": ["C#CCCCn1", "CCCCn1c", "CC(C)(C)CCC1(c2"] 4 | } -------------------------------------------------------------------------------- /icolos/external_documentation/REINVENT_result.json: -------------------------------------------------------------------------------- 1 | { 2 | "results": [ 3 | { 4 | "values_key": "score", 5 | "values": [1.0, 2.1, 3.2, "", "", 4.3, 7.0] 6 | } 7 | ], 8 | "names": ["mol1", "mol2", "mol3", "mol4", "mol5", "mol6", "ref_mol"] 9 | } -------------------------------------------------------------------------------- /icolos/pyproject.toml: -------------------------------------------------------------------------------- 1 | [build-system] 2 | requires = ["setuptools", "wheel"] 3 | build-backend = "setuptools.build_meta" -------------------------------------------------------------------------------- /icolos/setup.py: -------------------------------------------------------------------------------- 1 | from setuptools import setup, find_namespace_packages 2 | from pathlib import Path 3 | 4 | long_description = (Path(__file__).parent / "README.md").read_text() 5 | 6 | setup( 7 | name="icolos", 8 | maintainer="Christian Margreitter, Harry Moore", 9 | version="1.10.0", 10 | url="https://github.com/MolecularAI/Icolos", 11 | packages=find_namespace_packages(where="src"), 12 | package_dir={"": "src"}, 13 | description="Icolos Workflow Manager", 14 | long_description=long_description, 15 | long_description_content_type="text/markdown", 16 | python_requires=">=3.8", 17 | entry_points={ 18 | "console_scripts": [ 19 | "icolos = icolos.scripts.executor:main", 20 | "validator = icolos.scripts.validator:main", 21 | "sdf2smi = icolos.scripts.sdf2smi:main", 22 | ] 23 | }, 24 | ) 25 | -------------------------------------------------------------------------------- /icolos/src/icolos/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/config/amber/default_mmpbsa.in: -------------------------------------------------------------------------------- 1 | &general 2 | startframe=1, endframe=5000000000, verbose=2, 3 | / 4 | &gb 5 | igb=5, saltcon=0.150, 6 | / 7 | -------------------------------------------------------------------------------- /icolos/src/icolos/config/cosmo/default_cosmo.config: -------------------------------------------------------------------------------- 1 | 2 | unit notempty wtln ehfile 3 | !! generated by COSMOthermX !! 4 | f = mol.cosmo 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | henry= 2 tc=25.0 GSOLV 21 | henry= 3 tc=25.0 GSOLV 22 | henry= 4 tc=25.0 GSOLV 23 | henry= 5 tc=25.0 GSOLV 24 | henry= 6 tc=25.0 GSOLV 25 | henry= 7 tc=25.0 GSOLV 26 | henry= 8 tc=25.0 GSOLV 27 | henry= 9 tc=25.0 GSOLV 28 | henry= 10 tc=25.0 GSOLV -------------------------------------------------------------------------------- /icolos/src/icolos/config/desmond/config.msj: -------------------------------------------------------------------------------- 1 | task { 2 | task = "desmond:auto" 3 | } 4 | 5 | build_geometry { 6 | add_counterion = { 7 | ion = Cl 8 | number = neutralize_system 9 | } 10 | box = { 11 | shape = orthorhombic 12 | size = [10.0 10.0 10.0 ] 13 | size_type = buffer 14 | } 15 | override_forcefield = S-OPLS 16 | rezero_system = false 17 | solvent = TIP3P 18 | } 19 | 20 | assign_forcefield { 21 | forcefield = S-OPLS 22 | water = TIP3P 23 | } -------------------------------------------------------------------------------- /icolos/src/icolos/config/schemas/schemas.py: -------------------------------------------------------------------------------- 1 | import os 2 | import json 3 | from typing import Tuple 4 | 5 | from icolos.utils.enums.general_utils_enums import JSONSchemasEnum 6 | from icolos.utils.general.files_paths import attach_root_path 7 | 8 | _JSE = JSONSchemasEnum() 9 | 10 | 11 | def _load_schema(path: str) -> dict: 12 | try: 13 | with open(path, "r") as f: 14 | schema_data = f.read() 15 | schema = json.loads(schema_data) 16 | except json.JSONDecodeError: 17 | print(f"Could not load or parse schema file {path}, skipping.") 18 | schema = {} 19 | return schema 20 | 21 | 22 | def _construct_absolute_path(sub_schema: str) -> str: 23 | rel_path = "src/icolos/config/schemas/" 24 | return attach_root_path(os.path.join(rel_path, "".join([sub_schema, ".json"]))) 25 | 26 | 27 | def construct_workflow_schema() -> Tuple[dict, str]: 28 | path = _construct_absolute_path(_JSE.WORKFLOW_SCHEMA) 29 | return _load_schema(path), os.path.dirname(path) 30 | -------------------------------------------------------------------------------- /icolos/src/icolos/config/schemas/workflow.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "http://json-schema.org/draft-07/schema#", 3 | "title": "Workflow schema", 4 | "type": "object", 5 | "additionalProperties": false, 6 | "properties": { 7 | "workflow": { 8 | "type": "object", 9 | "additionalProperties": false, 10 | "properties": { 11 | "header": { 12 | "type": "object", 13 | "$ref": "header.json" 14 | }, 15 | "steps": { 16 | "type": "array", 17 | "items": { 18 | "type": "object", 19 | "$ref": "step.json" 20 | }, 21 | "minItems": 1 22 | } 23 | }, 24 | "required": ["header", "steps"] 25 | } 26 | }, 27 | "required": ["workflow"] 28 | } 29 | -------------------------------------------------------------------------------- /icolos/src/icolos/config/unit_tests_config/cosmo/cosmo.config: -------------------------------------------------------------------------------- 1 | 2 | unit notempty wtln ehfile 3 | !! generated by COSMOthermX !! 4 | f = mol.cosmo 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | henry= 2 tc=25.0 GSOLV 21 | henry= 3 tc=25.0 GSOLV 22 | henry= 4 tc=25.0 GSOLV 23 | henry= 5 tc=25.0 GSOLV 24 | henry= 6 tc=25.0 GSOLV 25 | henry= 7 tc=25.0 GSOLV 26 | henry= 8 tc=25.0 GSOLV 27 | henry= 9 tc=25.0 GSOLV 28 | henry= 10 tc=25.0 GSOLV -------------------------------------------------------------------------------- /icolos/src/icolos/config/unit_tests_config/cosmo/example.cosmo.config: -------------------------------------------------------------------------------- 1 | 2 | unit notempty wtln ehfile 3 | !! generated by COSMOthermX !! 4 | f = mol.cosmo 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | henry= 2 tc=25.0 GSOLV 21 | henry= 3 tc=25.0 GSOLV 22 | henry= 4 tc=25.0 GSOLV 23 | henry= 5 tc=25.0 GSOLV 24 | henry= 6 tc=25.0 GSOLV 25 | henry= 7 tc=25.0 GSOLV 26 | henry= 8 tc=25.0 GSOLV 27 | henry= 9 tc=25.0 GSOLV 28 | henry= 10 tc=25.0 GSOLV -------------------------------------------------------------------------------- /icolos/src/icolos/config_containers/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/config_containers/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/config_containers/workflow_container.py: -------------------------------------------------------------------------------- 1 | from icolos.config_containers.container import ConfContainer 2 | 3 | 4 | class WorkflowContainer(ConfContainer): 5 | def __init__(self, conf, validation=True): 6 | super().__init__(conf=conf) 7 | 8 | # TODO: include validation with JSON Schema 9 | if validation: 10 | self.validate() 11 | 12 | def validate(self): 13 | pass 14 | -------------------------------------------------------------------------------- /icolos/src/icolos/core/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/core/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/core/composite_agents/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/core/composite_agents/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/core/containers/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/core/containers/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/core/flow_control/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/core/flow_control/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/core/step_dispatch/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/core/step_dispatch/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/core/step_utils/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/core/step_utils/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/core/step_utils/rdkit_utils.py: -------------------------------------------------------------------------------- 1 | from rdkit import Chem 2 | 3 | 4 | def to_smiles(mol, isomericSmiles=False): 5 | """ 6 | Converts a Mol object into a canonical SMILES string. 7 | :param mol: Mol object. 8 | :return: A SMILES string. 9 | """ 10 | return Chem.MolToSmiles(mol, isomericSmiles=isomericSmiles) 11 | -------------------------------------------------------------------------------- /icolos/src/icolos/core/workflow_steps/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/core/workflow_steps/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/core/workflow_steps/autodockvina/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/core/workflow_steps/autodockvina/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/core/workflow_steps/calculation/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/core/workflow_steps/calculation/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/core/workflow_steps/ccdc/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/core/workflow_steps/ccdc/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/core/workflow_steps/confgen/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/core/workflow_steps/confgen/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/core/workflow_steps/confgen/base.py: -------------------------------------------------------------------------------- 1 | from pydantic import BaseModel 2 | from icolos.core.workflow_steps.step import StepBase 3 | 4 | 5 | class StepConfgenBase(StepBase, BaseModel): 6 | def __init__(self, **data): 7 | super().__init__(**data) 8 | -------------------------------------------------------------------------------- /icolos/src/icolos/core/workflow_steps/fpocket/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/core/workflow_steps/fpocket/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/core/workflow_steps/gromacs/__init__.py: -------------------------------------------------------------------------------- 1 | from icolos.core.workflow_steps.gromacs.cluster import StepGMXCluster 2 | from icolos.core.workflow_steps.gromacs.editconf import StepGMXEditConf 3 | from icolos.core.workflow_steps.gromacs.genion import StepGMXGenion 4 | from icolos.core.workflow_steps.gromacs.grompp import StepGMXGrompp 5 | from icolos.core.workflow_steps.gromacs.mdrun import StepGMXMDrun 6 | from icolos.core.workflow_steps.gromacs.pdb2gmx import StepGMXPdb2gmx 7 | from icolos.core.workflow_steps.gromacs.solvate import StepGMXSolvate 8 | from icolos.core.workflow_steps.gromacs.trjconv import StepGMXTrjconv 9 | from icolos.core.workflow_steps.gromacs.clusters_ts import StepClusterTS 10 | from icolos.core.workflow_steps.gromacs.rsmd import StepGMXrmsd 11 | -------------------------------------------------------------------------------- /icolos/src/icolos/core/workflow_steps/io/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/core/workflow_steps/io/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/core/workflow_steps/io/base.py: -------------------------------------------------------------------------------- 1 | from pydantic import BaseModel 2 | from icolos.core.workflow_steps.step import StepBase 3 | from icolos.utils.enums.step_enums import StepBaseEnum 4 | 5 | _SBE = StepBaseEnum 6 | 7 | 8 | class StepIOBase(StepBase, BaseModel): 9 | def __init__(self, **data): 10 | super().__init__(**data) 11 | -------------------------------------------------------------------------------- /icolos/src/icolos/core/workflow_steps/io/initialize_compound.py: -------------------------------------------------------------------------------- 1 | from pydantic import BaseModel 2 | 3 | from icolos.utils.general.icolos_exceptions import StepFailed 4 | from icolos.core.workflow_steps.io.base import StepIOBase 5 | from icolos.core.workflow_steps.step import _LE 6 | 7 | 8 | class StepInitializeCompound(StepIOBase, BaseModel): 9 | def __init__(self, **data): 10 | super().__init__(**data) 11 | 12 | def execute(self): 13 | if len(self.data.compounds) == 0: 14 | raise StepFailed( 15 | "Compound initialization step failed - no Compound objects generated." 16 | ) 17 | self._logger.log( 18 | f"Step {self.step_id} initialized {len(self.get_compounds())} compounds.", 19 | _LE.INFO, 20 | ) 21 | -------------------------------------------------------------------------------- /icolos/src/icolos/core/workflow_steps/openff/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/core/workflow_steps/openff/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/core/workflow_steps/prediction/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/core/workflow_steps/prediction/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/core/workflow_steps/schrodinger/__init__.py: -------------------------------------------------------------------------------- 1 | from icolos.core.workflow_steps.schrodinger.prime import StepPrime 2 | from icolos.core.workflow_steps.schrodinger.macromodel import StepMacromodel 3 | from icolos.core.workflow_steps.schrodinger.ligprep import StepLigprep 4 | from icolos.core.workflow_steps.schrodinger.glide import StepGlide 5 | from icolos.core.workflow_steps.schrodinger.prepwizard import StepPrepwizard 6 | from icolos.core.workflow_steps.schrodinger.fep_plus_setup import StepFepPlusSetup 7 | from icolos.core.workflow_steps.schrodinger.fep_plus_execution import StepFepPlusExec 8 | from icolos.core.workflow_steps.schrodinger.desmond_preprocessor import StepDesmondSetup 9 | from icolos.core.workflow_steps.schrodinger.desmond_exec import StepDesmondExec 10 | from icolos.core.workflow_steps.schrodinger.residue_scanning import StepResidueScanning 11 | -------------------------------------------------------------------------------- /icolos/src/icolos/core/workflow_steps/schrodinger/fep_analysis.py: -------------------------------------------------------------------------------- 1 | from icolos.core.workflow_steps.schrodinger.fep_base import StepFEPBase 2 | from icolos.utils.enums.step_enums import StepBaseEnum, StepFepPlusEnum 3 | from icolos.utils.enums.program_parameters import FepPlusEnum 4 | 5 | from pydantic import BaseModel 6 | 7 | _FE = FepPlusEnum() 8 | _SFE = StepFepPlusEnum() 9 | _SBE = StepBaseEnum 10 | 11 | 12 | class StepFepPlusAnalysis(StepFEPBase, BaseModel): 13 | """ 14 | Standalone class to analyse data from a previous fep job 15 | """ 16 | 17 | def __init__(self, **data): 18 | super().__init__(**data) 19 | 20 | def execute(self): 21 | """ 22 | Analyses the map produced from an FEP run 23 | """ 24 | tmp_dir = self._prepare_tmpdir() 25 | self.data.generic.write_out_all_files(tmp_dir) 26 | self._extract_log_file_data(tmp_dir) 27 | self._remove_temporary(tmp_dir) 28 | -------------------------------------------------------------------------------- /icolos/src/icolos/core/workflow_steps/structure_prediction/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/core/workflow_steps/structure_prediction/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/core/workflow_steps/structure_prediction/disicl.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/core/workflow_steps/structure_prediction/disicl.py -------------------------------------------------------------------------------- /icolos/src/icolos/core/workflow_steps/structure_prediction/rosetta_abinitio.py: -------------------------------------------------------------------------------- 1 | from icolos.core.workflow_steps.step import StepBase 2 | from pydantic import BaseModel 3 | from icolos.utils.execute_external.rosetta import RosettaExecutor 4 | 5 | # Wrapping for Rosetta ab initio structure prediction 6 | # Note the execution is finicky, and requires some proper set up to get this to work 7 | # we run everything locally, since public web servers are not an option for us. 8 | # some config is required to get make_fragments.pl to run with all its dependencies in place 9 | 10 | 11 | class StepRosettaAbinitio(StepBase, BaseModel): 12 | def __init__(self, **data): 13 | super().__init__(data) 14 | 15 | self._inititalize_backend(executor=RosettaExecutor) 16 | -------------------------------------------------------------------------------- /icolos/src/icolos/loggers/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/loggers/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/loggers/agentlogger.py: -------------------------------------------------------------------------------- 1 | import logging 2 | 3 | from icolos.loggers.base_logger import BaseLogger 4 | 5 | 6 | class AgentLogger(BaseLogger): 7 | def __init__(self): 8 | super().__init__() 9 | 10 | def _initialize_logger(self): 11 | logger = logging.getLogger(self._LE.LOGGER_AGENT) 12 | return logger 13 | -------------------------------------------------------------------------------- /icolos/src/icolos/loggers/blank_logger.py: -------------------------------------------------------------------------------- 1 | import logging 2 | 3 | from icolos.loggers.base_logger import BaseLogger 4 | 5 | 6 | class BlankLogger(BaseLogger): 7 | """This logger serves as a "verbatim" interface.""" 8 | 9 | def __init__(self): 10 | super().__init__() 11 | 12 | def _initialize_logger(self): 13 | logger = logging.getLogger(self._LE.LOGGER_BLANK) 14 | return logger 15 | -------------------------------------------------------------------------------- /icolos/src/icolos/loggers/entrypoint_logger.py: -------------------------------------------------------------------------------- 1 | import logging 2 | 3 | from icolos.loggers.base_logger import BaseLogger 4 | 5 | 6 | class EntryPointLogger(BaseLogger): 7 | def __init__(self): 8 | super().__init__() 9 | 10 | def _initialize_logger(self): 11 | logger = logging.getLogger(self._LE.LOGGER_ENTRYPOINT) 12 | return logger 13 | -------------------------------------------------------------------------------- /icolos/src/icolos/loggers/iologger.py: -------------------------------------------------------------------------------- 1 | import logging 2 | 3 | from icolos.loggers.base_logger import BaseLogger 4 | 5 | 6 | class IOLogger(BaseLogger): 7 | def __init__(self): 8 | super().__init__() 9 | 10 | def _initialize_logger(self): 11 | logger = logging.getLogger(self._LE.LOGGER_IO) 12 | return logger 13 | -------------------------------------------------------------------------------- /icolos/src/icolos/loggers/logger_utils.py: -------------------------------------------------------------------------------- 1 | def log_multiline_string(logger, level: str, multi_line_string: str): 2 | splitted = multi_line_string.split("\n") 3 | for line in splitted: 4 | logger.log(line, level) 5 | -------------------------------------------------------------------------------- /icolos/src/icolos/loggers/steplogger.py: -------------------------------------------------------------------------------- 1 | import logging 2 | import multiprocessing 3 | 4 | from icolos.loggers.base_logger import BaseLogger 5 | 6 | 7 | class StepLogger(BaseLogger): 8 | def __init__(self): 9 | super().__init__() 10 | 11 | def _initialize_logger(self): 12 | # logger = multiprocessing.log_to_stderr() 13 | # logger.name = self._LE.LOGGER_STEP 14 | logger = logging.getLogger(self._LE.LOGGER_STEP) 15 | return logger 16 | -------------------------------------------------------------------------------- /icolos/src/icolos/scripts/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/scripts/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/utils/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/utils/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/utils/constants.py: -------------------------------------------------------------------------------- 1 | CONSTANT_T = 298 # temperature in Kelvin 2 | CONSTANT_KB = 0.00198720425864 # Boltzmann constant in kcal / mol / Kelvin 3 | -------------------------------------------------------------------------------- /icolos/src/icolos/utils/entry_point_functions/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/utils/entry_point_functions/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/utils/enums/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/utils/enums/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/utils/enums/entry_points.py: -------------------------------------------------------------------------------- 1 | class ExecutorEnum: 2 | 3 | RUNTIME_GLOBAL_VARIABLE_WORKDIR = "work_dir" 4 | RUNTIME_GLOBAL_VARIABLE_ENTRYPOINTDIR = "entrypoint_dir" 5 | RUNTIME_GLOBAL_VARIABLE_CONFIGDIR = "config_dir" 6 | RUNTIME_GLOBAL_VARIABLE_PACKAGEDIR = "package_dir" 7 | 8 | # try to find the internal value and return 9 | def __getattr__(self, name): 10 | if name in self: 11 | return name 12 | raise AttributeError 13 | 14 | # prohibit any attempt to set any values 15 | def __setattr__(self, key, value): 16 | raise ValueError("No changes allowed.") 17 | -------------------------------------------------------------------------------- /icolos/src/icolos/utils/enums/execution_enums.py: -------------------------------------------------------------------------------- 1 | from enum import Enum 2 | 3 | 4 | class ExecutionPlatformEnum(str, Enum): 5 | LOCAL = "local" 6 | SLURM = "slurm" 7 | PARTITION = "partition" 8 | TIME = "time" 9 | GRES = "gres" 10 | MEM = "mem" 11 | CORES = "cores" 12 | CORE = "core" 13 | GPU = "gpu" 14 | SERIAL = "serial" 15 | -------------------------------------------------------------------------------- /icolos/src/icolos/utils/enums/flow_control_enums.py: -------------------------------------------------------------------------------- 1 | from icolos.core.flow_control.iterator import StepIterator 2 | from icolos.core.workflow_steps.active_learning.virtual_screening import ( 3 | StepActiveLearning, 4 | ) 5 | from icolos.utils.enums.step_enums import StepBaseEnum 6 | 7 | _SBE = StepBaseEnum 8 | 9 | 10 | class FlowControlInitializationEnum: 11 | # These steps are responsible for initializing other steps as part of their execution 12 | # Keep these separate to the main pool of steps to avoid circular imports 13 | 14 | FLOW_CONTROL_INIT_DICT = { 15 | _SBE.STEP_ITERATOR: StepIterator, 16 | _SBE.STEP_ACTIVE_LEARNING: StepActiveLearning, 17 | } 18 | -------------------------------------------------------------------------------- /icolos/src/icolos/utils/enums/input_enums.py: -------------------------------------------------------------------------------- 1 | class InputEnum: 2 | 3 | SOURCE_FIELD_COMPOUNDS = "compounds" 4 | TARGET_FIELD_COMPOUNDS = "compounds" 5 | TARGET_FIELD_CONFORMERS = "conformers" 6 | 7 | # REINVENT-compatible JSON input 8 | JSON_NAMES = "names" 9 | JSON_SMILES = "smiles" 10 | 11 | # try to find the internal value and return 12 | def __getattr__(self, name): 13 | if name in self: 14 | return name 15 | raise AttributeError 16 | 17 | # prohibit any attempt to set any values 18 | def __setattr__(self, key, value): 19 | raise ValueError("No changes allowed.") 20 | -------------------------------------------------------------------------------- /icolos/src/icolos/utils/enums/logging_enums.py: -------------------------------------------------------------------------------- 1 | class LoggingConfigEnum: 2 | 3 | # set levels (for now, they match to the "logging" default ones) 4 | DEBUG = "debug" 5 | INFO = "info" 6 | WARNING = "warning" 7 | ERROR = "error" 8 | EXCEPTION = "exception" 9 | 10 | # paths to the configuration JSONs that are shipped with Icolos 11 | PATH_CONFIG_DEFAULT = "src/icolos/config/logging/default.json" 12 | PATH_CONFIG_VERBOSE = "src/icolos/config/logging/verbose.json" 13 | PATH_CONFIG_DEBUG = "src/icolos/config/logging/debug.json" 14 | PATH_CONFIG_TUTORIAL = "src/icolos/config/logging/tutorial.json" 15 | 16 | # high-level loggers defined in the configurations 17 | LOGGER_IO = "io" 18 | LOGGER_STEP = "step" 19 | LOGGER_AGENT = "agent" 20 | LOGGER_ENTRYPOINT = "entrypoint" 21 | LOGGER_BLANK = "blank" 22 | 23 | # prohibit any attempt to set any values 24 | def __setattr__(self, key, value): 25 | raise ValueError("No changes allowed.") 26 | -------------------------------------------------------------------------------- /icolos/src/icolos/utils/enums/parallelization.py: -------------------------------------------------------------------------------- 1 | from enum import Enum 2 | 3 | 4 | class ParallelizationEnum(str, Enum): 5 | 6 | STATUS_READY = "ready" 7 | STATUS_RUNNING = "running" 8 | STATUS_SUCCESS = "success" 9 | STATUS_FAILED = "failed" 10 | 11 | # try to find the internal value and return 12 | # def __getattr__(self, name): 13 | # if name in self: 14 | # return name 15 | # raise AttributeError 16 | 17 | # # prohibit any attempt to set any values 18 | # def __setattr__(self, key, value): 19 | # raise ValueError("No changes allowed.") 20 | -------------------------------------------------------------------------------- /icolos/src/icolos/utils/execute_external/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/utils/execute_external/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/utils/general/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/src/icolos/utils/general/__init__.py -------------------------------------------------------------------------------- /icolos/src/icolos/utils/general/arparse_bool_extension.py: -------------------------------------------------------------------------------- 1 | import argparse 2 | 3 | 4 | def str2bool(inp): 5 | if isinstance(inp, bool): 6 | return inp 7 | if inp.lower() in ("yes", "true", "t", "y", "1"): 8 | return True 9 | elif inp.lower() in ("no", "false", "f", "n", "0"): 10 | return False 11 | else: 12 | raise argparse.ArgumentTypeError( 13 | "Expected castable string or boolean value as input." 14 | ) 15 | -------------------------------------------------------------------------------- /icolos/src/icolos/utils/general/icolos_exceptions.py: -------------------------------------------------------------------------------- 1 | class ExecutionFailed(Exception): 2 | pass 3 | 4 | 5 | class StepFailed(Exception): 6 | pass 7 | 8 | 9 | class ContainerCorrupted(Exception): 10 | pass 11 | 12 | 13 | def get_exception_message(e: Exception): 14 | if e is None: 15 | return None 16 | if hasattr(e, "message"): 17 | return e.message 18 | else: 19 | return e 20 | 21 | 22 | def get_exception_type(e: Exception) -> str: 23 | if e is None: 24 | return None 25 | return type(e).__name__ 26 | -------------------------------------------------------------------------------- /icolos/src/icolos/utils/general/molecules.py: -------------------------------------------------------------------------------- 1 | from rdkit import Chem 2 | from rdkit.Chem import rdmolops 3 | 4 | from icolos.utils.enums.compound_enums import CompoundTagsEnum 5 | 6 | 7 | def get_charge_for_molecule(molecule: Chem.Mol, add_as_tag=False) -> int: 8 | _MTE = CompoundTagsEnum() 9 | charge = rdmolops.GetFormalCharge(molecule) 10 | if add_as_tag: 11 | molecule.SetProp(_MTE.FORMAL_CHARGE_TAG, str(charge)) 12 | return charge 13 | 14 | 15 | def write_molecule_to_sdf(path: str, molecule: Chem.Mol): 16 | if molecule is None or not isinstance(molecule, Chem.Mol): 17 | raise ValueError("Function requires input attribute to be an RDkit molecule.") 18 | writer = Chem.SDWriter(path) 19 | writer.write(molecule) 20 | writer.close() 21 | -------------------------------------------------------------------------------- /icolos/src/icolos/utils/general/print_log.py: -------------------------------------------------------------------------------- 1 | import os 2 | from icolos.loggers.blank_logger import BlankLogger 3 | 4 | 5 | def print_log_file(path: str, logger, level): 6 | logger_blank = BlankLogger() 7 | if os.path.isfile(path): 8 | with open(path, "r") as log_file: 9 | log_file_raw = log_file.readlines() 10 | logger.log(f"Printing log file {path}:\n", level) 11 | for line in log_file_raw: 12 | logger_blank.log(line.rstrip("\n"), level) 13 | logger_blank.log("", level) 14 | logger.log("--- End file", level) 15 | -------------------------------------------------------------------------------- /icolos/src/icolos/utils/general/progress_bar.py: -------------------------------------------------------------------------------- 1 | def get_progress_bar_string( 2 | done, total, prefix="", suffix="", decimals=1, length=100, fill="█" 3 | ): 4 | percent = ("{0:." + str(decimals) + "f}").format(100 * (done / float(total))) 5 | filledLength = int(length * done // total) 6 | bar = fill * filledLength + "-" * (length - filledLength) 7 | return f"{prefix}|{bar}| {percent}% {suffix}" 8 | -------------------------------------------------------------------------------- /icolos/src/icolos/utils/general/strings.py: -------------------------------------------------------------------------------- 1 | def stringify(obj): 2 | """Converts all objects in a dict to str, recursively.""" 3 | if isinstance(obj, dict): 4 | return {str(key): stringify(value) for key, value in obj.items()} 5 | elif isinstance(obj, list): 6 | return [stringify(value) for value in obj] 7 | else: 8 | return str(obj) 9 | -------------------------------------------------------------------------------- /icolos/tests/CREST/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.CREST.test_CREST_confgen import * 2 | -------------------------------------------------------------------------------- /icolos/tests/OMEGA/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.OMEGA.test_OMEGA_confgen import Test_OMEGA_confgen 2 | -------------------------------------------------------------------------------- /icolos/tests/Turbomole/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.Turbomole.test_Turbomole import * 2 | -------------------------------------------------------------------------------- /icolos/tests/XTB/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.XTB.test_XTB_confgen import Test_XTB_confgen 2 | -------------------------------------------------------------------------------- /icolos/tests/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/tests/__init__.py -------------------------------------------------------------------------------- /icolos/tests/autodockvina/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.autodockvina.test_adv_docking import * 2 | from tests.autodockvina.test_adv_target_prep import * 3 | -------------------------------------------------------------------------------- /icolos/tests/boltzmann_weighting/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.boltzmann_weighting.test_boltzmann_weighting import Test_BoltzmannWeighting 2 | -------------------------------------------------------------------------------- /icolos/tests/ccdc/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.ccdc.test_gold_docking import * 2 | -------------------------------------------------------------------------------- /icolos/tests/clustering/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.clustering.test_clustering import * 2 | -------------------------------------------------------------------------------- /icolos/tests/composite_agents/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.composite_agents.test_workflow import * 2 | -------------------------------------------------------------------------------- /icolos/tests/containers/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.containers.test_compound import * 2 | from tests.containers.test_generic import * 3 | from tests.containers.test_perturbation_map import * 4 | -------------------------------------------------------------------------------- /icolos/tests/cosmo/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.cosmo.test_Cosmo import * 2 | -------------------------------------------------------------------------------- /icolos/tests/esp_sim/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.esp_sim.test_esp_sim import * 2 | -------------------------------------------------------------------------------- /icolos/tests/feature_counter/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.feature_counter.test_feature_counter import Test_FeatureCounter 2 | -------------------------------------------------------------------------------- /icolos/tests/flow_control/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.flow_control.test_iterator import * 2 | -------------------------------------------------------------------------------- /icolos/tests/flow_control/test_slurm_interface.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/tests/flow_control/test_slurm_interface.py -------------------------------------------------------------------------------- /icolos/tests/gromacs/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.gromacs.test_editconf import * 2 | from tests.gromacs.test_genion import * 3 | from tests.gromacs.test_solvate import * 4 | from tests.gromacs.test_mdrun import * 5 | from tests.gromacs.test_pdb2gmx import * 6 | from tests.gromacs.test_grompp import * 7 | from tests.gromacs.test_trjconv import * 8 | from tests.gromacs.test_cluster import * 9 | from tests.gromacs.test_mmpbsa import * 10 | from tests.gromacs.test_cluster_ts import * 11 | 12 | # from tests.gromacs.test_do_dssp import * 13 | from tests.gromacs.test_trjcat import * 14 | from tests.gromacs.test_rmsd import * 15 | -------------------------------------------------------------------------------- /icolos/tests/gromacs/test_removelig.py: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /icolos/tests/integration_tests/__init__.py: -------------------------------------------------------------------------------- 1 | # from tests.integration_tests.test_fep_plus import * 2 | from tests.integration_tests.test_docking import * 3 | from tests.integration_tests.test_gromacs import * 4 | 5 | from tests.integration_tests.test_rmsd_iter import * 6 | -------------------------------------------------------------------------------- /icolos/tests/io/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.io.test_initialize_compound import * 2 | from tests.io.test_embedder import * 3 | from tests.io.test_data_manipulation import Test_DataManipulation 4 | -------------------------------------------------------------------------------- /icolos/tests/jazzy/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.jazzy.test_jazzy import * 2 | -------------------------------------------------------------------------------- /icolos/tests/kallisto/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.kallisto.test_kallisto import * 2 | -------------------------------------------------------------------------------- /icolos/tests/lomap/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/tests/lomap/__init__.py -------------------------------------------------------------------------------- /icolos/tests/mdpocket/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.mdpocket.test_md_pocket import * 2 | -------------------------------------------------------------------------------- /icolos/tests/openff/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/icolos/tests/openff/__init__.py -------------------------------------------------------------------------------- /icolos/tests/panther/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.panther.test_panther import * 2 | -------------------------------------------------------------------------------- /icolos/tests/pmx/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.pmx.test_prepare_simulations import * 2 | from tests.pmx.test_analyse import * 3 | from tests.pmx.test_prepare_transitions import * 4 | from tests.pmx.test_atomMapping import * 5 | from tests.pmx.test_ligandHybrid import * 6 | from tests.pmx.test_box_water_ions import * 7 | from tests.pmx.test_setup_workpath import * 8 | from tests.pmx.test_assemble_systems import * 9 | from tests.pmx.test_run_simulations import * 10 | from tests.pmx.test_abfe import * 11 | -------------------------------------------------------------------------------- /icolos/tests/pmx/test_doublebox.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | import os 3 | from tests.tests_paths import export_unit_test_env_vars 4 | from icolos.utils.general.files_paths import attach_root_path 5 | 6 | 7 | class Test_PMXdoublebox(unittest.TestCase): 8 | @classmethod 9 | def setUpClass(cls): 10 | cls._test_dir = attach_root_path("tests/junk/pmx/doublebox") 11 | if not os.path.isdir(cls._test_dir): 12 | os.makedirs(cls._test_dir) 13 | 14 | export_unit_test_env_vars() 15 | 16 | def setUp(self): 17 | pass 18 | 19 | def test_XYZ(self): 20 | pass 21 | -------------------------------------------------------------------------------- /icolos/tests/pmx/test_genlib.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | import os 3 | from tests.tests_paths import export_unit_test_env_vars 4 | from icolos.utils.general.files_paths import attach_root_path 5 | 6 | 7 | class Test_PMXgenlib(unittest.TestCase): 8 | @classmethod 9 | def setUpClass(cls): 10 | cls._test_dir = attach_root_path("tests/junk/pmx/genlib") 11 | if not os.path.isdir(cls._test_dir): 12 | os.makedirs(cls._test_dir) 13 | 14 | export_unit_test_env_vars() 15 | 16 | def setUp(self): 17 | pass 18 | 19 | def test_XYZ(self): 20 | pass 21 | -------------------------------------------------------------------------------- /icolos/tests/pmx/test_gentop.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | import os 3 | from icolos.core.composite_agents.workflow import WorkFlow 4 | from icolos.core.containers.generic import GenericData 5 | from icolos.core.containers.perturbation_map import Edge, PerturbationMap 6 | from icolos.core.workflow_steps.pmx.gentop import StepPMXgentop 7 | from icolos.utils.enums.step_enums import StepBaseEnum 8 | from tests.tests_paths import PATHS_EXAMPLEDATA, export_unit_test_env_vars 9 | from icolos.utils.general.files_paths import attach_root_path 10 | 11 | _SBE = StepBaseEnum 12 | 13 | 14 | class Test_PMXgentop(unittest.TestCase): 15 | @classmethod 16 | def setUpClass(cls): 17 | cls._test_dir = attach_root_path("tests/junk/pmx/gentop") 18 | if not os.path.isdir(cls._test_dir): 19 | os.makedirs(cls._test_dir) 20 | 21 | export_unit_test_env_vars() 22 | 23 | def setUp(self): 24 | pass 25 | 26 | def test_pmx_gentop(self): 27 | pass 28 | -------------------------------------------------------------------------------- /icolos/tests/prediction/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.prediction.test_predictor import * 2 | from tests.prediction.test_model_building import * 3 | -------------------------------------------------------------------------------- /icolos/tests/rms_filter/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.rms_filter.test_rmsfilter import * 2 | -------------------------------------------------------------------------------- /icolos/tests/rmsd/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.rmsd.test_rmsd import Test_RMSD 2 | -------------------------------------------------------------------------------- /icolos/tests/schrodinger/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.schrodinger.test_ligprep import * 2 | from tests.schrodinger.test_glide import * 3 | from tests.schrodinger.test_macromodel import * 4 | from tests.schrodinger.test_fep_plus_setup import * 5 | from tests.schrodinger.test_fep_plus_execution import * 6 | from tests.schrodinger.test_fep_analysis import * 7 | from tests.schrodinger.test_prepwizard import * 8 | from tests.schrodinger.test_prime import * 9 | from tests.schrodinger.test_desmond_production import * 10 | from tests.schrodinger.test_desmond_setup import * 11 | -------------------------------------------------------------------------------- /icolos/tests/shaep/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.shaep.test_shaep import * 2 | -------------------------------------------------------------------------------- /icolos/tests/step_utils/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.step_utils.test_input_merger import * 2 | from tests.step_utils.test_input_preparator import * 3 | from tests.step_utils.test_run_variables_resolver import * 4 | from tests.step_utils.test_writeout import * 5 | -------------------------------------------------------------------------------- /icolos/tests/structure_prediction/__init__.py: -------------------------------------------------------------------------------- 1 | from tests.structure_prediction.test_peptide_embedder import * 2 | from tests.structure_prediction.test_pdb_fixer import * 3 | 4 | # from tests.structure_prediction.test_dssp import * 5 | # TODO: work out why the dssp unit test hangs sometimes 6 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/.gitignore: -------------------------------------------------------------------------------- 1 | __pycache__ 2 | *.pyc 3 | package.json 4 | .vscode 5 | tags 6 | .idea 7 | /reinvent_scoring/configs/config.json 8 | /README_internal.md 9 | 10 | dist 11 | build 12 | reinvent_scoring_molecular_ai.egg-info 13 | 14 | # Coverage.py output 15 | .coverage 16 | htmlcov/ 17 | 18 | # Python memory_profiler output 19 | mprofile_*.dat 20 | /reinvent_scoring.egg-info/dependency_links.txt 21 | /reinvent_scoring.egg-info/PKG-INFO 22 | /reinvent_scoring.egg-info/SOURCES.txt 23 | /reinvent_scoring.egg-info/top_level.txt 24 | unittest_reinvent/fixtures/integration_tests_config.json -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/Jenkinsfile: -------------------------------------------------------------------------------- 1 | @Library('scp-model-pipeline') _ 2 | 3 | buildEnvAndTest this, 4 | buildCommand: 'conda env update --name=base --file=environment.yml', 5 | testCommand: 'python main_test.py --unittests', 6 | teamsWebHook: 'https://azcollaboration.webhook.office.com/webhookb2/fad6dfa3-0530-4b65-b65f-f1e83bd6fb92@af8e89a3-d9ac-422f-ad06-cc4eb4214314/IncomingWebhook/32e5aa47806f4e8dacba65eff46ab71a/96efbb05-b287-40bd-beb5-eeade5bc63ea', 7 | buildSSHKeyId: 'add-ssh-key', 8 | name: 'Reinvent Scoring' 9 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/README.md: -------------------------------------------------------------------------------- 1 | # Introduction 2 | This package contains the scoring functions for REINVENT. 3 | 4 | # Installation 5 | To install in REINVENT's environment either install from repo or use `pip install reinvent-scoring` for the latest 6 | official release. -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/main_test.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # coding=utf-8 3 | import pytest 4 | import argparse 5 | import sys 6 | 7 | 8 | TESTS_FOLDER = 'unittest_reinvent' 9 | 10 | 11 | parser = argparse.ArgumentParser(description='Run reinvent_scoring tests') 12 | parser.add_argument( 13 | '--unittests', action='store_true', 14 | help='Only run unittests (Please indicate either integration or unittests flag)' 15 | ) 16 | parser.add_argument( 17 | '--integration', action='store_true', 18 | help='Only run integration tests (Please indicate either integration or unittests flag)' 19 | ) 20 | 21 | args, _ = parser.parse_known_args() 22 | 23 | 24 | if args.unittests: 25 | pytest_args = ['-m', 'not integration', TESTS_FOLDER] 26 | elif args.integration: 27 | pytest_args = ['-m', 'integration', TESTS_FOLDER] 28 | else: 29 | raise Exception('Please provide either --unittests or --integration flag.') 30 | 31 | 32 | if __name__ == '__main__': 33 | sys.exit(pytest.main(pytest_args)) 34 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/pytest.ini: -------------------------------------------------------------------------------- 1 | [pytest] 2 | markers = 3 | integration: marks tests that are integrated with other services 4 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/__init__.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring import * 2 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/__init__.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.function import * 2 | from reinvent_scoring.scoring.enums import * 3 | from reinvent_scoring.scoring.score_components import * 4 | 5 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 6 | from reinvent_scoring.scoring.score_summary import FinalSummary, ComponentSummary, LoggableComponent 7 | from reinvent_scoring.scoring.score_transformations import TransformationFactory 8 | from reinvent_scoring.scoring.scoring_function_factory import ScoringFunctionFactory 9 | from reinvent_scoring.scoring.scoring_function_parameters import ScoringFunctionParameters 10 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/component_parameters.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass 5 | class ComponentParameters: 6 | component_type: str 7 | name: str 8 | weight: float 9 | specific_parameters: dict = None 10 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/diversity_filters/__init__.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.diversity_filters.reinvent_core import IdenticalMurckoScaffold, NoScaffoldFilter, \ 2 | ScaffoldSimilarity, IdenticalTopologicalScaffold 3 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/diversity_filters/curriculum_learning/__init__.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.diversity_filters.curriculum_learning.diversity_filter_memory import DiversityFilterMemory 2 | from reinvent_scoring.scoring.diversity_filters.curriculum_learning.diversity_filter_parameters import \ 3 | DiversityFilterParameters 4 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/diversity_filters/curriculum_learning/column_names_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class ColumnNamesEnum: 6 | STEP: str = "Step" 7 | SCAFFOLD: str = "Scaffold" 8 | SMILES: str = "SMILES" 9 | METADATA: str = "Metadata" -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/diversity_filters/curriculum_learning/diversity_filter_parameters.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass 5 | class DiversityFilterParameters: 6 | name: str 7 | minscore: float = 0.4 8 | bucket_size: int = 25 9 | minsimilarity: float = 0.4 10 | penalty_multiplier: float = 0.5 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/diversity_filters/curriculum_learning/loggable_data_dto.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass 5 | class UpdateLoggableDataDTO: 6 | """This class is used by the Diversity Filters to log out metadata.""" 7 | input: str 8 | output: str 9 | likelihood: float = None 10 | prior_likelihood: float = None 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/diversity_filters/curriculum_learning/memory_record_dto.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from typing import List 3 | 4 | from reinvent_scoring.scoring.score_summary import ComponentSummary 5 | 6 | 7 | @dataclass 8 | class MemoryRecordDTO: 9 | id: int 10 | step: int 11 | score: float 12 | smile: str 13 | scaffold: str 14 | loggable_data: str 15 | components: List[ComponentSummary] 16 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/diversity_filters/curriculum_learning/update_diversity_filter_dto.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from typing import List 3 | 4 | from reinvent_scoring.scoring.diversity_filters.curriculum_learning.loggable_data_dto import UpdateLoggableDataDTO 5 | from reinvent_scoring.scoring.score_summary import FinalSummary 6 | 7 | 8 | @dataclass 9 | class UpdateDiversityFilterDTO: 10 | score_summary: FinalSummary 11 | loggable_data: List[UpdateLoggableDataDTO] 12 | step: int = 0 13 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/diversity_filters/lib_invent/__init__.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.diversity_filters.lib_invent.identical_murcko_scaffold import IdenticalMurckoScaffold 2 | from reinvent_scoring.scoring.diversity_filters.lib_invent.no_filter import NoFilter 3 | from reinvent_scoring.scoring.diversity_filters.lib_invent.no_filter_with_penalty import NoFilterWithPenalty 4 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/diversity_filters/lib_invent/diversity_filter.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.diversity_filters.lib_invent import NoFilter, NoFilterWithPenalty, IdenticalMurckoScaffold 2 | from reinvent_scoring.scoring.diversity_filters.lib_invent.base_diversity_filter import BaseDiversityFilter 3 | from reinvent_scoring.scoring.diversity_filters.lib_invent.diversity_filter_parameters import DiversityFilterParameters 4 | 5 | 6 | class DiversityFilter: 7 | 8 | def __new__(cls, parameters: DiversityFilterParameters) -> BaseDiversityFilter: 9 | all_filters = dict(NoFilter=NoFilter, 10 | IdenticalMurckoScaffold=IdenticalMurckoScaffold, 11 | NoFilterWithPenalty=NoFilterWithPenalty) 12 | div_filter = all_filters.get(parameters.name, KeyError(f"Invalid filter name: `{parameters.name}'")) 13 | return div_filter(parameters) 14 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/diversity_filters/lib_invent/diversity_filter_parameters.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass 5 | class DiversityFilterParameters: 6 | name: str 7 | minscore: float = 0.4 8 | bucket_size: int = 25 9 | minsimilarity: float = 0.4 10 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/diversity_filters/molformer/__init__.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.diversity_filters.molformer.identical_murcko_scaffold import IdenticalMurckoScaffold 2 | from reinvent_scoring.scoring.diversity_filters.molformer.no_filter import NoFilter 3 | from reinvent_scoring.scoring.diversity_filters.molformer.no_filter_with_penalty import NoFilterWithPenalty -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/diversity_filters/reinvent_core/__init__.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.diversity_filters.reinvent_core.identical_murcko_scaffold import IdenticalMurckoScaffold 2 | from reinvent_scoring.scoring.diversity_filters.reinvent_core.no_scaffold_filter import NoScaffoldFilter 3 | from reinvent_scoring.scoring.diversity_filters.reinvent_core.scaffold_similarity import ScaffoldSimilarity 4 | from reinvent_scoring.scoring.diversity_filters.reinvent_core.identical_topological_scaffold import IdenticalTopologicalScaffold 5 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/diversity_filters/reinvent_core/diversity_filter_parameters.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass 5 | class DiversityFilterParameters: 6 | name: str 7 | minscore: float = 0.4 8 | bucket_size: int = 25 9 | minsimilarity: float = 0.4 10 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/enums/container_type_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class ContainerType: 6 | SCIKIT_CONTAINER = "scikit_container" 7 | OPTUNA_CONTAINER = "optuna_container" 8 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/enums/descriptor_types_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class DescriptorTypesEnum(): 6 | ECFP = "ecfp" 7 | ECFP_COUNTS = "ecfp_counts" 8 | MACCS_KEYS = "maccs_keys" 9 | AVALON = "avalon" 10 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/enums/diversity_filter_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class DiversityFilterEnum: 6 | IDENTICAL_TOPOLOGICAL_SCAFFOLD = "IdenticalTopologicalScaffold" 7 | IDENTICAL_MURCKO_SCAFFOLD = "IdenticalMurckoScaffold" 8 | SCAFFOLD_SIMILARITY = "ScaffoldSimilarity" 9 | NO_FILTER = "NoFilter" 10 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/enums/environmental_variables_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class EnvironmentalVariablesEnum: 6 | PIP_URL = "PIP_URL" 7 | PIP_KEY = "PIP_KEY" 8 | PIP_GET_RESULTS = "PIP_GET_RESULTS" 9 | JAVA_HOME = "JAVA_HOME" 10 | CHEMAXON_HOME = "CHEMAXON_HOME" 11 | CHEMAXON_EXECUTOR_PATH = 'CHEMAXON_EXECUTOR_PATH' 12 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/enums/logging_mode_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class LoggingModeEnum: 6 | LOCAL = "local" 7 | REMOTE = "remote" 8 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/enums/rocs_similarity_measures_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class ROCSSimilarityMeasuresEnum(): 6 | TANIMOTO = "Tanimoto" 7 | REF_TVERSKY = "RefTversky" 8 | FIT_TVERSKY = "FitTversky" 9 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/enums/rocs_specific_parameters_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class ROCSSpecificParametersEnum(): 6 | ROCS_INPUT = "rocs_input" 7 | SHAPE_WEIGHT = "shape_weight" 8 | COLOR_WEIGHT = "color_weight" 9 | SIM_MEASURE = "similarity_measure" 10 | MAX_CPUS = "max_num_cpus" 11 | CUSTOM_CFF = "custom_cff" 12 | SAVE_ROCS_OVERLAYS = "save_rocs_overlays" 13 | ROCS_OVERLAYS_DIR = "rocs_overlays_dir" 14 | ROCS_OVERLAYS_PREFIX = "rocs_overlays_prefix" 15 | ENUM_STEREO = "enumerate_stereo" 16 | MAX_STEREO = "max_stereocenters" 17 | NEGATIVE_VOLUME = "negative_volume" 18 | PROTEIN_NEG_VOL_FILE = "protein_neg_vol_file" 19 | LIGAND_NEG_VOL_FILE = "ligand_neg_vol_file" 20 | MAX_CONFS = "max_confs" 21 | EWINDOW = "ewindow" 22 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/enums/scoring_function_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class ScoringFunctionNameEnum: 6 | CUSTOM_PRODUCT = "custom_product" 7 | CUSTOM_SUM = "custom_sum" 8 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/enums/transformation_parameters_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class TransformationParameters: 6 | TRANSFORMATION_TYPE = "transformation_type" 7 | LOW = "low" 8 | HIGH = "high" 9 | K = "k" 10 | COEF_DIV = "coef_div" 11 | COEF_SI = "coef_si" 12 | COEF_SE = "coef_se" 13 | TRUNCATE_LEFT = "truncate_left" 14 | TRUNCATE_RIGHT = "truncate_right" 15 | INTERPOLATION_MAP = "interpolation_map" 16 | 17 | 18 | TransformationParametersEnum = TransformationParameters() 19 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/enums/transformation_type_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class TransformationTypeEnum: 6 | DOUBLE_SIGMOID = "double_sigmoid" 7 | SIGMOID = "sigmoid" 8 | REVERSE_SIGMOID = "reverse_sigmoid" 9 | RIGHT_STEP = "right_step" 10 | LEFT_STEP = "left_step" 11 | STEP = "step" 12 | CUSTOM_INTERPOLATION = "custom_interpolation" 13 | NO_TRANSFORMATION = "no_transformation" 14 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/function/__init__.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.function.custom_product import CustomProduct 2 | from reinvent_scoring.scoring.function.custom_sum import CustomSum 3 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/predictive_model/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinvent_scoring/reinvent_scoring/scoring/predictive_model/__init__.py -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/predictive_model/base_model_container.py: -------------------------------------------------------------------------------- 1 | from abc import ABC, abstractmethod 2 | 3 | from typing import Dict, List 4 | 5 | 6 | class BaseModelContainer(ABC): 7 | 8 | @abstractmethod 9 | def predict(self, molecules: List, parameters: Dict): 10 | raise NotImplementedError("'predict' method is not implemented !") 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/__init__.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.score_components.aizynth import BuildingBlockAvailabilityComponent 2 | from reinvent_scoring.scoring.score_components.base_score_component import * 3 | from reinvent_scoring.scoring.score_components.synthetic_accessibility import * 4 | from reinvent_scoring.scoring.score_components.physchem import * 5 | from reinvent_scoring.scoring.score_components.pip import * 6 | from reinvent_scoring.scoring.score_components.structural import * 7 | from reinvent_scoring.scoring.score_components.physchem import * 8 | from reinvent_scoring.scoring.score_components.standard import * 9 | from reinvent_scoring.scoring.score_components.rocs import * 10 | from reinvent_scoring.scoring.score_components.link_invent import * 11 | from reinvent_scoring.scoring.score_components.active_learning import * 12 | from reinvent_scoring.scoring.score_components.console_invoked.external_process import ( 13 | ExternalProcess, 14 | ) 15 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/active_learning/__init__.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.score_components.active_learning.active_learning import ActiveLearning -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/active_learning/default_values.py: -------------------------------------------------------------------------------- 1 | ACTIVE_LEARNING_DEFAULT_VALUES = dict( 2 | AL_INPUT=None, 3 | AL_OUTPUT=None, 4 | WARMUP=0, 5 | TRAINING_POOL_START=0, 6 | TRAINING_POOL_EPOCHS_LIMIT=10, 7 | MAX_COMPOUNDS=1000, 8 | MOLECULAR_REPRESENTATION="Physchem", 9 | ORACLE_CHOICE="ROCS", 10 | ICOLOS_CONF_PATH=None, 11 | TARGET_PROPERTY=None, 12 | SURROGATE_MODEL="RandomForest", 13 | ACQUISTION_FUNCTION="UCB", 14 | ACQUISITION_SIZE=64, 15 | DIRECTION="maximise", 16 | LOOP_CONDITION=5, 17 | VIRTUAL_LIBRARY_ACQUISITION_SIZE=10, 18 | VIRTUAL_LIBRARY_LOOPS=6, 19 | PREDICTED_WEIGHTS=0.0, 20 | NOISE_LEVEL=False, 21 | CONFIDENCE_CUTOFF=False, 22 | RELATIVE_FRACTION=0.0, 23 | DROP_DUPLICATE_SMILES=False, 24 | N_LIG=0.0, 25 | NUM_CPUS=0, 26 | MAX_DOCKING_CALLS=100_000, 27 | SUB_SAMPLE = False, 28 | MPO_ACQUISITION = False, 29 | UCB_BETA_VALUE = 1.0 30 | ) 31 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/active_learning/scripts/__init__.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.score_components.active_learning.scripts.molecular_representations import * 2 | from reinvent_scoring.scoring.score_components.active_learning.scripts.acquisition_functions import * 3 | from reinvent_scoring.scoring.score_components.active_learning.scripts.oracles import * 4 | from reinvent_scoring.scoring.score_components.active_learning.scripts.retrospectiveReinvent import * 5 | from reinvent_scoring.scoring.score_components.active_learning.scripts.surrogate_models import * -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/aizynth/__init__.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.score_components.aizynth.building_block_availability_component import \ 2 | BuildingBlockAvailabilityComponent 3 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/console_invoked/mmp/__init__.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.score_components.console_invoked.mmp.mmp import MMP 2 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/console_invoked/mmp/mmp_parameter_dto.py: -------------------------------------------------------------------------------- 1 | from pydantic import BaseModel, Field, conlist 2 | 3 | from reinvent_scoring.scoring.score_components.console_invoked.mmp.mmpdb_parameter_dto import MmpdbParameterDTO 4 | 5 | 6 | class MMPParameterDTO(BaseModel): 7 | mmp_temporary_directory: str = None 8 | mmp_reference_molecules: conlist(str, min_length=1) 9 | value_mapping: dict = {'MMP': 1.0, 'Not MMP': 0.5} 10 | mmpdb_parameters: MmpdbParameterDTO = Field(default_factory=MmpdbParameterDTO) 11 | mmp_debug: bool = False -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/console_invoked/mmp/mmpdb_parameter_dto.py: -------------------------------------------------------------------------------- 1 | 2 | from pydantic import BaseModel 3 | 4 | 5 | class MmpdbParameterDTO(BaseModel): 6 | num_of_cuts: int = 1 7 | delimiter: str = 'comma' 8 | max_variable_heavies: int = 40 9 | max_variable_ratio: float = 0.33 -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/link_invent/linker_effective_length.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.link_invent.base_link_invent_component import BaseLinkInventComponent 3 | 4 | 5 | class LinkerEffectiveLength(BaseLinkInventComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_linker_property(self, labeled_mol): 10 | return self._linker_descriptor.effective_length(labeled_mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/link_invent/linker_graph_length.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.link_invent.base_link_invent_component import BaseLinkInventComponent 3 | 4 | 5 | class LinkerGraphLength(BaseLinkInventComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_linker_property(self, labeled_mol): 10 | return self._linker_descriptor.max_graph_length(labeled_mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/link_invent/linker_length_ratio.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.link_invent.base_link_invent_component import BaseLinkInventComponent 3 | 4 | 5 | class LinkerLengthRatio(BaseLinkInventComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_linker_property(self, labeled_mol): 10 | return self._linker_descriptor.length_ratio(labeled_mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/link_invent/linker_mol_weight.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.link_invent.base_link_invent_component import BaseLinkInventComponent 3 | 4 | 5 | class LinkerMolWeight(BaseLinkInventComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_linker_property(self, labeled_mol): 10 | return self._linker_descriptor.mol_weight(labeled_mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/link_invent/linker_num_aliphatic_rings.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.link_invent.base_link_invent_component import BaseLinkInventComponent 3 | 4 | 5 | class LinkerNumAliphaticRings(BaseLinkInventComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_linker_property(self, labeled_mol): 10 | return self._linker_descriptor.num_aliphatic_rings(labeled_mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/link_invent/linker_num_aromatic_rings.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.link_invent.base_link_invent_component import BaseLinkInventComponent 3 | 4 | 5 | class LinkerNumAromaticRings(BaseLinkInventComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_linker_property(self, labeled_mol): 10 | return self._linker_descriptor.num_aromatic_rings(labeled_mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/link_invent/linker_num_hba.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.link_invent.base_link_invent_component import BaseLinkInventComponent 3 | 4 | 5 | class LinkerNumHBA(BaseLinkInventComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_linker_property(self, labeled_mol): 10 | return self._linker_descriptor.num_hba(labeled_mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/link_invent/linker_num_hbd.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.link_invent.base_link_invent_component import BaseLinkInventComponent 3 | 4 | 5 | class LinkerNumHBD(BaseLinkInventComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_linker_property(self, labeled_mol): 10 | return self._linker_descriptor.num_hbd(labeled_mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/link_invent/linker_num_rings.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.link_invent.base_link_invent_component import BaseLinkInventComponent 3 | 4 | 5 | class LinkerNumRings(BaseLinkInventComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_linker_property(self, labeled_mol): 10 | return self._linker_descriptor.num_rings(labeled_mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/link_invent/linker_num_sp2_atoms.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.link_invent.base_link_invent_component import BaseLinkInventComponent 3 | 4 | 5 | class LinkerNumSP2Atoms(BaseLinkInventComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_linker_property(self, labeled_mol): 10 | return self._linker_descriptor.num_sp2_atoms(labeled_mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/link_invent/linker_num_sp3_atoms.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.link_invent.base_link_invent_component import BaseLinkInventComponent 3 | 4 | 5 | class LinkerNumSP3Atoms(BaseLinkInventComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_linker_property(self, labeled_mol): 10 | return self._linker_descriptor.num_sp3_atoms(labeled_mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/link_invent/linker_num_sp_atoms.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.link_invent.base_link_invent_component import BaseLinkInventComponent 3 | 4 | 5 | class LinkerNumSPAtoms(BaseLinkInventComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_linker_property(self, labeled_mol): 10 | return self._linker_descriptor.num_sp_atoms(labeled_mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/link_invent/linker_ratio_rotatable_bonds.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.link_invent.base_link_invent_component import BaseLinkInventComponent 3 | 4 | 5 | class LinkerRatioRotatableBonds(BaseLinkInventComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_linker_property(self, labeled_mol): 10 | return self._linker_descriptor.ratio_rotatable_bonds(labeled_mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/physchem/graph_length.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.physchem.base_physchem_component import BasePhysChemComponent 3 | 4 | 5 | class GraphLength(BasePhysChemComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_phys_chem_property(self, mol): 10 | return self._phys_chem_descriptors.maximum_graph_length(mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/physchem/hba.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.physchem.base_physchem_component import BasePhysChemComponent 3 | 4 | 5 | class HBA_Lipinski(BasePhysChemComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_phys_chem_property(self, mol): 10 | return self._phys_chem_descriptors.hba_libinski(mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/physchem/hbd.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.physchem.base_physchem_component import BasePhysChemComponent 3 | 4 | 5 | class HBD_Lipinski(BasePhysChemComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_phys_chem_property(self, mol): 10 | return self._phys_chem_descriptors.hbd_libinski(mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/physchem/mol_weight.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.physchem.base_physchem_component import BasePhysChemComponent 3 | 4 | 5 | class MolWeight(BasePhysChemComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_phys_chem_property(self, mol): 10 | return self._phys_chem_descriptors.mol_weight(mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/physchem/num_aliphatic_rings.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.physchem.base_physchem_component import BasePhysChemComponent 3 | 4 | 5 | class NumAliphaticRings(BasePhysChemComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_phys_chem_property(self, mol): 10 | return self._phys_chem_descriptors.number_of_aliphatic_rings(mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/physchem/num_aromatic_rings.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.physchem.base_physchem_component import BasePhysChemComponent 3 | 4 | 5 | class NumAromaticRings(BasePhysChemComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_phys_chem_property(self, mol): 10 | return self._phys_chem_descriptors.number_of_aromatic_rings(mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/physchem/num_rings.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.physchem.base_physchem_component import BasePhysChemComponent 3 | 4 | 5 | class NumRings(BasePhysChemComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_phys_chem_property(self, mol): 10 | return self._phys_chem_descriptors.number_of_rings(mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/physchem/number_of_stereo_centers.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.physchem.base_physchem_component import BasePhysChemComponent 3 | 4 | 5 | class NumberOfStereoCenters(BasePhysChemComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_phys_chem_property(self, mol): 10 | return self._phys_chem_descriptors.number_of_stereo_centers(mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/physchem/rot_bonds.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.physchem.base_physchem_component import BasePhysChemComponent 3 | 4 | 5 | class RotatableBonds(BasePhysChemComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_phys_chem_property(self, mol): 10 | return self._phys_chem_descriptors.number_of_rotatable_bonds(mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/physchem/slogp.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.physchem.base_physchem_component import BasePhysChemComponent 3 | 4 | 5 | class SlogP(BasePhysChemComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_phys_chem_property(self, mol): 10 | return self._phys_chem_descriptors.slog_p(mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/physchem/tpsa.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 2 | from reinvent_scoring.scoring.score_components.physchem.base_physchem_component import BasePhysChemComponent 3 | 4 | 5 | class PSA(BasePhysChemComponent): 6 | def __init__(self, parameters: ComponentParameters): 7 | super().__init__(parameters) 8 | 9 | def _calculate_phys_chem_property(self, mol): 10 | return self._phys_chem_descriptors.tpsa(mol) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/rocs/__init__.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.score_components.rocs.rocs_similarity import RocsSimilarity 2 | from reinvent_scoring.scoring.score_components.rocs.parallel_rocs_similarity import ParallelRocsSimilarity 3 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/rocs/default_values.py: -------------------------------------------------------------------------------- 1 | ROCS_DEFAULT_VALUES = dict( 2 | MAX_STEREO=0, 3 | MAX_CPUS=4, 4 | SAVE_ROCS_OVERLAYS=False, 5 | ENUM_STEREO=False, 6 | MAX_CONFS=200, 7 | EWINDOW=10, 8 | ROCS_OVERLAYS_DIR=None, 9 | ROCS_OVERLAYS_PREFIX="", 10 | PROTEIN_NEG_VOL_FILE=None, 11 | LIGAND_NEG_VOL_FILE=None, 12 | ROCS_INPUT=None, 13 | CUSTOM_CFF="", 14 | SHAPE_WEIGHT=None, 15 | COLOR_WEIGHT=None, 16 | NEGATIVE_VOLUME=False, 17 | ) -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/standard/__init__.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.score_components.standard.group_count import GroupCount 2 | from reinvent_scoring.scoring.score_components.standard.selectivity_component import SelectivityComponent 3 | from reinvent_scoring.scoring.score_components.standard.custom_alerts_component import CustomAlerts 4 | from reinvent_scoring.scoring.score_components.standard.jaccard_distance import JaccardDistance 5 | from reinvent_scoring.scoring.score_components.standard.matching_substructure import MatchingSubstructure 6 | from reinvent_scoring.scoring.score_components.standard.predictive_property_component import PredictivePropertyComponent 7 | from reinvent_scoring.scoring.score_components.standard.chemprop_component import ChemPropComponent 8 | from reinvent_scoring.scoring.score_components.standard.qed_score import QedScore 9 | from reinvent_scoring.scoring.score_components.standard.tanimoto_similarity import TanimotoSimilarity 10 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/structural/__init__.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.score_components.structural.azdock import AZdock 2 | from reinvent_scoring.scoring.score_components.structural.dockstream import DockStream 3 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/synthetic_accessibility/__init__.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.score_components.synthetic_accessibility.sas_component import SASComponent 2 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/synthetic_accessibility/fpscores.pkl.gz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinvent_scoring/reinvent_scoring/scoring/score_components/synthetic_accessibility/fpscores.pkl.gz -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/scoring_function_parameters.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from typing import List 3 | 4 | 5 | @dataclass 6 | class ScoringFunctionParameters: 7 | name: str 8 | parameters: List[dict] 9 | parallel: bool = False -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/reinvent_scoring/scoring/utils.py: -------------------------------------------------------------------------------- 1 | import os 2 | 3 | 4 | def _is_development_environment() -> bool: 5 | try: 6 | is_dev = os.environ.get("DEVELOPMENT_ENVIRONMENT", False) 7 | return is_dev 8 | except: 9 | return False -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/setup.py: -------------------------------------------------------------------------------- 1 | import setuptools 2 | 3 | with open("README.md", "r") as fh: 4 | long_description = fh.read() 5 | 6 | setuptools.setup( 7 | name="reinvent_scoring", 8 | version="0.0.79", 9 | author="MolecularAI", 10 | author_email="patronov@gmail.com", 11 | description="Scoring functions for Reinvent", 12 | long_description=long_description, 13 | long_description_content_type="text/markdown", 14 | url="https://github.com/MolecularAI/reinvent-scoring.git", 15 | package_data={ 16 | "reinvent_scoring": [ 17 | "scoring/score_components/synthetic_accessibility/fpscores.pkl.gz", 18 | ] 19 | }, 20 | packages=setuptools.find_packages(exclude='unittest_reinvent'), 21 | classifiers=[ 22 | "Programming Language :: Python :: 3", 23 | "License :: OSI Approved :: MIT License", 24 | "Operating System :: OS Independent", 25 | ], 26 | python_requires='>=3.7', 27 | ) 28 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/diversity_filter_tests/fixtures.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | from typing import List 3 | 4 | from reinvent_scoring.scoring.score_summary import FinalSummary, ComponentSummary 5 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 6 | from reinvent_scoring.scoring.enums.scoring_function_component_enum import ScoringFunctionComponentNameEnum 7 | 8 | 9 | def tanimoto_scaffold_filter_arrangement(smiles: List[str], scores: List[float], 10 | valid_idx: List[int]) -> FinalSummary: 11 | component_parameters = ComponentParameters( 12 | component_type=ScoringFunctionComponentNameEnum().TANIMOTO_SIMILARITY, 13 | name="tanimoto_similarity", 14 | weight=1., 15 | specific_parameters={}) 16 | 17 | component_score_summary = ComponentSummary(scores, component_parameters) 18 | return FinalSummary(np.array(scores), smiles, valid_idx, [component_score_summary]) -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/diversity_filter_tests/test_diversity_filter_memory.py: -------------------------------------------------------------------------------- 1 | import pandas as pd 2 | 3 | from unittest_reinvent.diversity_filter_tests.test_diversity_filter_memory_base import BaseDiversityFilterMemory 4 | 5 | 6 | class TestDiversityFilterMemoryAdd(BaseDiversityFilterMemory): 7 | 8 | def test_empty(self): 9 | self.assertFalse(self.mem.smiles_exists(self.smi)) 10 | self.assertEqual(self.mem.number_of_smiles(), 0) 11 | 12 | def test_set_memory(self): 13 | df = pd.DataFrame({"x": [1, 2, 3]}) 14 | self.mem.set_memory(df) 15 | 16 | self.assertEqual(len(self.mem.get_memory()), len(df)) 17 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/diversity_filter_tests/test_diversity_filter_memory_base.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | 3 | from reinvent_scoring.scoring.diversity_filters.curriculum_learning import DiversityFilterMemory 4 | from unittest_reinvent.fixtures.test_data import TOLUENE, ANILINE, BENZENE 5 | 6 | 7 | class BaseDiversityFilterMemory(unittest.TestCase): 8 | 9 | def setUp(self): 10 | self.mem = DiversityFilterMemory() 11 | self.smi = TOLUENE 12 | self.smi2 = ANILINE 13 | self.scaffold = BENZENE 14 | self.step = 10 15 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/diversity_filter_tests/test_murcko_scaffold_memory_size.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.diversity_filter_tests.test_murcko_scaffold_base import BaseMurckoScaffoldFilter 2 | 3 | 4 | class TestMurckoScaffoldMemorySize(BaseMurckoScaffoldFilter): 5 | 6 | def test_dataframe_size(self): 7 | dataframe = self.scaffold_filter.get_memory_as_dataframe() 8 | self.assertEqual(2, len(dataframe)) 9 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/diversity_filter_tests/test_murcko_scaffold_valid_addition.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.diversity_filters.curriculum_learning.update_diversity_filter_dto import \ 2 | UpdateDiversityFilterDTO 3 | from unittest_reinvent.diversity_filter_tests.fixtures import tanimoto_scaffold_filter_arrangement 4 | from unittest_reinvent.diversity_filter_tests.test_murcko_scaffold_base import BaseMurckoScaffoldFilter 5 | from unittest_reinvent.fixtures.test_data import COCAINE 6 | 7 | class TestMurckoScaffoldValidAddition(BaseMurckoScaffoldFilter): 8 | 9 | def setUp(self): 10 | super().setUp() 11 | 12 | final_summary = tanimoto_scaffold_filter_arrangement([COCAINE], [1.0], [0]) 13 | self.update_dto = UpdateDiversityFilterDTO(final_summary, []) 14 | 15 | def test_valid_addition(self): 16 | self.scaffold_filter.update_score(self.update_dto) 17 | self.assertEqual(3, self.scaffold_filter._diversity_filter_memory.number_of_scaffolds()) 18 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/diversity_filter_tests/test_no_filter_memory_size.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.diversity_filter_tests.test_tanimoto_similarity_base import BaseTanimotoSimilarity 2 | 3 | 4 | class TestNoFilterMemorySize(BaseTanimotoSimilarity): 5 | 6 | def test_dataframe_size(self): 7 | dataframe = self.scaffold_filter.get_memory_as_dataframe() 8 | self.assertEqual(2, len(dataframe)) 9 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/diversity_filter_tests/test_no_filter_superfluous_addition.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.diversity_filters.curriculum_learning.update_diversity_filter_dto import \ 2 | UpdateDiversityFilterDTO 3 | from unittest_reinvent.diversity_filter_tests.test_tanimoto_similarity_base import BaseTanimotoSimilarity 4 | from unittest_reinvent.fixtures.test_data import ASPIRIN 5 | from unittest_reinvent.diversity_filter_tests.fixtures import tanimoto_scaffold_filter_arrangement 6 | 7 | 8 | class TestNoFilterSuperfluousAddition(BaseTanimotoSimilarity): 9 | 10 | def setUp(self): 11 | super().setUp() 12 | 13 | final_summary = tanimoto_scaffold_filter_arrangement([ASPIRIN], [1.0], [0]) 14 | self.update_dto = UpdateDiversityFilterDTO(final_summary, []) 15 | 16 | def test_superfluous_addition(self): 17 | self.scaffold_filter.update_score(self.update_dto) 18 | self.assertEqual(2, self.scaffold_filter._diversity_filter_memory.number_of_scaffolds()) 19 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/diversity_filter_tests/test_no_filter_valid_addition.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.diversity_filters.curriculum_learning.update_diversity_filter_dto import \ 2 | UpdateDiversityFilterDTO 3 | from unittest_reinvent.diversity_filter_tests.test_tanimoto_similarity_base import BaseTanimotoSimilarity 4 | from unittest_reinvent.fixtures.test_data import BUTANE 5 | from unittest_reinvent.diversity_filter_tests.fixtures import tanimoto_scaffold_filter_arrangement 6 | 7 | 8 | class TestNoFilterValidAddition(BaseTanimotoSimilarity): 9 | 10 | def setUp(self): 11 | super().setUp() 12 | 13 | final_summary = tanimoto_scaffold_filter_arrangement([BUTANE], [1.0], [0]) 14 | self.update_dto = UpdateDiversityFilterDTO(final_summary, []) 15 | 16 | def test_valid_addition(self): 17 | self.scaffold_filter.update_score(self.update_dto) 18 | self.assertEqual(3, self.scaffold_filter._diversity_filter_memory.number_of_scaffolds()) 19 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/diversity_filter_tests/test_scaffold_similarity_filter_memory_set.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.diversity_filter_tests.test_tanimoto_similarity_base import BaseTanimotoSimilarity 2 | 3 | 4 | class TestScaffoldSimilarityMemorySize(BaseTanimotoSimilarity): 5 | 6 | def test_dataframe_size(self): 7 | dataframe = self.scaffold_filter.get_memory_as_dataframe() 8 | self.assertEqual(2, len(dataframe)) 9 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/diversity_filter_tests/test_topological_scaffold_filter_memory_size.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.diversity_filter_tests.test_topological_scaffold_filter_base import BaseTopologicalScaffoldFilter 2 | 3 | 4 | class TestTopologicalScaffoldMemorySize(BaseTopologicalScaffoldFilter): 5 | 6 | def test_dataframe_size(self): 7 | dataframe = self.scaffold_filter.get_memory_as_dataframe() 8 | self.assertEqual(2, len(dataframe)) 9 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/fixtures/dummy_classification_model.pkl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinvent_scoring/unittest_reinvent/fixtures/dummy_classification_model.pkl -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/fixtures/dummy_regression_model.pkl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinvent_scoring/unittest_reinvent/fixtures/dummy_regression_model.pkl -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/__init__.py: -------------------------------------------------------------------------------- 1 | 2 | from unittest_reinvent.scoring_tests.scoring_functions import * 3 | from unittest_reinvent.scoring_tests.scoring_transformations import * 4 | 5 | from unittest_reinvent.scoring_tests.scoring_components import * 6 | from unittest_reinvent.scoring_tests.physchem import * 7 | from unittest_reinvent.scoring_tests.link_invent import * 8 | 9 | from unittest_reinvent.scoring_tests.scoring_3d import * 10 | from unittest_reinvent.scoring_tests.structural import * 11 | from unittest_reinvent.scoring_tests.console_invoked import * 12 | from unittest_reinvent.scoring_tests.synthetic_accessibility import * 13 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/fixtures/__init__.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.scoring_tests.fixtures.predictive_model_fixtures import * 2 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/fixtures/azdock_data/azdock_OpenEye_receptor.oeb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/fixtures/azdock_data/azdock_OpenEye_receptor.oeb -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/fixtures/azgard_data/azgard_cox2_grid.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/fixtures/azgard_data/azgard_cox2_grid.zip -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/fixtures/chemprop_models/model.pt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/fixtures/chemprop_models/model.pt -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/fixtures/dockstream_data/dockstream_OpenEye_receptor.oeb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/fixtures/dockstream_data/dockstream_OpenEye_receptor.oeb -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/fixtures/icolos_data/icolos_cox2_grid.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/fixtures/icolos_data/icolos_cox2_grid.zip -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/physchem/test_graph_length_score_no_transformation.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import numpy.testing as npt 3 | 4 | from unittest_reinvent.fixtures.test_data import CELECOXIB, METAMIZOLE, AMOXAPINE, METHOXYHYDRAZINE, COCAINE 5 | from unittest_reinvent.scoring_tests.physchem.base_setup import BaseSetup 6 | 7 | 8 | class TestGraphLengthScoreNoTransformation(BaseSetup): 9 | 10 | def setUp(self): 11 | super().setup_attrs() 12 | super().init(self.sf_enum.GRAPH_LENGTH, {}) 13 | super().setUp() 14 | 15 | def test_graph_length_1(self): 16 | smiles = [CELECOXIB, METAMIZOLE, AMOXAPINE, METHOXYHYDRAZINE, COCAINE] 17 | values = np.array([12., 10., 9., 3., 10.]) 18 | score = self.sf_state.get_final_score(smiles=smiles) 19 | npt.assert_array_almost_equal(score.total_score, values, 2) 20 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/physchem/test_hba_lipinski_score_no_transformation.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import numpy.testing as npt 3 | 4 | from unittest_reinvent.fixtures.test_data import CELECOXIB, METAMIZOLE, AMOXAPINE, METHOXYHYDRAZINE, COCAINE 5 | from unittest_reinvent.scoring_tests.physchem.base_setup import BaseSetup 6 | 7 | 8 | class TestHbaScoreNoTransformation(BaseSetup): 9 | 10 | def setUp(self): 11 | super().setup_attrs() 12 | super().init(self.sf_enum.NUM_HBA_LIPINSKI, {}) 13 | super().setUp() 14 | 15 | def test_hba_1(self): 16 | smiles = [CELECOXIB, METAMIZOLE, AMOXAPINE, METHOXYHYDRAZINE, COCAINE] 17 | values = np.array([4., 6., 4., 3., 5.]) 18 | score = self.sf_state.get_final_score(smiles=smiles) 19 | npt.assert_array_equal(score.total_score, values) -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/physchem/test_hbd_lipinski_score_no_transformation.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import numpy.testing as npt 3 | 4 | from unittest_reinvent.fixtures.test_data import CELECOXIB, METAMIZOLE, AMOXAPINE, METHOXYHYDRAZINE, COCAINE 5 | from unittest_reinvent.scoring_tests.physchem.base_setup import BaseSetup 6 | 7 | 8 | class TestHbdScoreNoTransformation(BaseSetup): 9 | 10 | def setUp(self): 11 | super().setup_attrs() 12 | super().init(self.sf_enum.NUM_HBD_LIPINSKI, {}) 13 | super().setUp() 14 | 15 | def test_hbd_1(self): 16 | smiles = [CELECOXIB, METAMIZOLE, AMOXAPINE, METHOXYHYDRAZINE, COCAINE] 17 | values = np.array([1., 1., 1., 2., 0.]) 18 | score = self.sf_state.get_final_score(smiles=smiles) 19 | npt.assert_array_equal(score.total_score, values) 20 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/physchem/test_mw_score_no_transformation.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import numpy.testing as npt 3 | 4 | from unittest_reinvent.fixtures.test_data import CELECOXIB, METAMIZOLE, AMOXAPINE, METHOXYHYDRAZINE, COCAINE 5 | from unittest_reinvent.scoring_tests.physchem.base_setup import BaseSetup 6 | 7 | 8 | class TestMwScoreNoTransformation(BaseSetup): 9 | 10 | def setUp(self): 11 | super().setup_attrs() 12 | super().init(self.sf_enum.MOLECULAR_WEIGHT, {}) 13 | super().setUp() 14 | 15 | def test_mw_1(self): 16 | smiles = [CELECOXIB, METAMIZOLE, AMOXAPINE, METHOXYHYDRAZINE, COCAINE] 17 | values = np.array([381.38, 311.36, 313.79, 62.07, 303.36]) 18 | score = self.sf_state.get_final_score(smiles=smiles) 19 | npt.assert_array_almost_equal(score.total_score, values, 2) 20 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/physchem/test_num_aliphatic_rings.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import numpy.testing as npt 3 | 4 | from unittest_reinvent.fixtures.test_data import BENZENE, ANILINE, BENZO_A_PYRENE, DECALIN, PACLITAXEL 5 | from unittest_reinvent.scoring_tests.physchem.base_setup import BaseSetup 6 | 7 | 8 | class TestNumAliphaticRingsScoreNoTransformation(BaseSetup): 9 | 10 | def setUp(self): 11 | super().setup_attrs() 12 | super().init(self.sf_enum.NUM_ALIPHATIC_RINGS, {}) 13 | super().setUp() 14 | 15 | def test_num_rings_1(self): 16 | smiles = [BENZENE, ANILINE, BENZO_A_PYRENE, DECALIN, PACLITAXEL] 17 | values = np.array([0., 0., 0., 2., 4.]) 18 | score = self.sf_state.get_final_score(smiles=smiles) 19 | npt.assert_array_almost_equal(score.total_score, values, 2) 20 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/physchem/test_num_rings_score_no_transformation.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import numpy.testing as npt 3 | 4 | from unittest_reinvent.fixtures.test_data import BENZENE, ANILINE, BENZO_A_PYRENE, DECALIN, PACLITAXEL 5 | from unittest_reinvent.scoring_tests.physchem.base_setup import BaseSetup 6 | 7 | 8 | class TestNumRingsScoreNoTransformation(BaseSetup): 9 | 10 | def setUp(self): 11 | super().setup_attrs() 12 | super().init(self.sf_enum.NUM_RINGS, {}) 13 | super().setUp() 14 | 15 | def test_num_rings_1(self): 16 | smiles = [BENZENE, ANILINE, BENZO_A_PYRENE, DECALIN, PACLITAXEL] 17 | values = np.array([1., 1., 5., 2., 7.]) 18 | score = self.sf_state.get_final_score(smiles=smiles) 19 | npt.assert_array_almost_equal(score.total_score, values, 2) 20 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/physchem/test_num_rot_bonds_score_no_transformation.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import numpy.testing as npt 3 | 4 | from unittest_reinvent.fixtures.test_data import CELECOXIB, METAMIZOLE, AMOXAPINE, METHOXYHYDRAZINE, COCAINE 5 | from unittest_reinvent.scoring_tests.physchem.base_setup import BaseSetup 6 | 7 | 8 | class TestNumRotBondsScoreNoTransformation(BaseSetup): 9 | 10 | def setUp(self): 11 | super().setup_attrs() 12 | super().init(self.sf_enum.NUM_ROTATABLE_BONDS, {}) 13 | super().setUp() 14 | 15 | def test_num_rot_1(self): 16 | smiles = [CELECOXIB, METAMIZOLE, AMOXAPINE, METHOXYHYDRAZINE, COCAINE] 17 | values = np.array([3., 4., 0., 1., 3.]) 18 | score = self.sf_state.get_final_score(smiles=smiles) 19 | npt.assert_array_equal(score.total_score, values) 20 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/physchem/test_slogp_score_no_transformation.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import numpy.testing as npt 3 | 4 | from unittest_reinvent.fixtures.test_data import CELECOXIB, METAMIZOLE, AMOXAPINE, METHOXYHYDRAZINE, COCAINE 5 | from unittest_reinvent.scoring_tests.physchem.base_setup import BaseSetup 6 | 7 | 8 | class TestSlogpScoreNotransformation(BaseSetup): 9 | 10 | def setUp(self): 11 | super().setup_attrs() 12 | super().init(self.sf_enum.SLOGP, {}) 13 | super().setUp() 14 | 15 | def test_slogp_1(self): 16 | smiles = [CELECOXIB, METAMIZOLE, AMOXAPINE, METHOXYHYDRAZINE, COCAINE] 17 | values = np.array([3.51, 0.77, 3.43, -0.99, 1.87]) 18 | score = self.sf_state.get_final_score(smiles=smiles) 19 | npt.assert_array_almost_equal(score.total_score, values, 2) 20 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/physchem/test_tpsa_score_no_transformation.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import numpy.testing as npt 3 | 4 | from unittest_reinvent.fixtures.test_data import CELECOXIB, METAMIZOLE, AMOXAPINE, METHOXYHYDRAZINE, COCAINE 5 | from unittest_reinvent.scoring_tests.physchem.base_setup import BaseSetup 6 | 7 | 8 | class TestTpsaScoreNoTransformation(BaseSetup): 9 | 10 | def setUp(self): 11 | super().setup_attrs() 12 | super().init(self.sf_enum.TPSA, {}) 13 | super().setUp() 14 | 15 | def test_tpsa_1(self): 16 | smiles = [CELECOXIB, METAMIZOLE, AMOXAPINE, METHOXYHYDRAZINE, COCAINE] 17 | values = np.array([77.98, 84.54, 36.86, 47.28, 55.84]) 18 | score = self.sf_state.get_final_score(smiles=smiles) 19 | npt.assert_array_almost_equal(score.total_score, values, 2) 20 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/scoring_3d/fixtures.py: -------------------------------------------------------------------------------- 1 | from typing import Dict, Any 2 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 3 | 4 | 5 | def component_parameters(component_type: str, specific_parameters: Dict[str, Any], name: str = "rocs_similarity", ) \ 6 | -> ComponentParameters: 7 | return ComponentParameters(component_type=component_type, 8 | name=name, 9 | weight=1., 10 | specific_parameters=specific_parameters) 11 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/scoring_components/aizynth/test_building_block_availability.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring import ComponentSpecificParametersEnum 2 | from reinvent_scoring.scoring.component_parameters import ComponentParameters 3 | 4 | from reinvent_scoring.scoring.score_components.aizynth.building_block_availability_component import ( 5 | drop_atommap, 6 | ) 7 | 8 | 9 | def test_drop_atommap(): 10 | assert drop_atommap("CCC") == "CCC" 11 | assert drop_atommap("CCC[C:0]C[C:12]") == "[C]C[C]CCC" 12 | assert drop_atommap("[C:0]CC([O:1])=[O:0]") == "[C]CC([O])=O" 13 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/scoring_components/base_matching_substructure.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | 3 | from reinvent_scoring import ScoringFunctionComponentNameEnum, ComponentParameters 4 | 5 | 6 | class BaseTestMatchingSubstructure(unittest.TestCase): 7 | 8 | def setUp(self): 9 | sf_enum = ScoringFunctionComponentNameEnum() 10 | self.parameters = ComponentParameters(component_type=sf_enum.MATCHING_SUBSTRUCTURE, 11 | name="matching_substructure", 12 | weight=1., 13 | specific_parameters={"smiles":self.smiles}) 14 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/scoring_components/test_custom_alerts_default_alerts.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | 3 | from reinvent_scoring.scoring.score_components import CustomAlerts 4 | from unittest_reinvent.scoring_tests.fixtures.predictive_model_fixtures import create_custom_alerts_configuration 5 | from unittest_reinvent.scoring_tests.scoring_components.fixtures import score_single, score 6 | from unittest_reinvent.fixtures.test_data import HEXANE, PENTANE, METAMIZOLE, CAFFEINE 7 | import numpy.testing as npt 8 | 9 | 10 | class TestCustomAlertsWithDefaultAlerts(unittest.TestCase): 11 | 12 | @classmethod 13 | def setUpClass(cls): 14 | parameters = create_custom_alerts_configuration() 15 | cls.component = CustomAlerts(parameters) 16 | 17 | def test_alert_1(self): 18 | npt.assert_almost_equal(score(self.component, [PENTANE, HEXANE]), [1, 1]) 19 | 20 | def test_alert_2(self): 21 | npt.assert_almost_equal(score_single(self.component, METAMIZOLE), 0) 22 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/scoring_components/test_invalid_matching_substructure.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.score_components import MatchingSubstructure 2 | from unittest_reinvent.fixtures.test_data import INVALID 3 | from unittest_reinvent.scoring_tests.scoring_components.base_matching_substructure import \ 4 | BaseTestMatchingSubstructure 5 | 6 | 7 | class TestInvalidMatchingSubstructure(BaseTestMatchingSubstructure): 8 | 9 | def setUp(self): 10 | self.smiles = [INVALID] 11 | super().setUp() 12 | 13 | def test_match_invalid_structure_1(self): 14 | with self.assertRaises(IOError) as context: 15 | _ = MatchingSubstructure(self.parameters) 16 | msg = f"Invalid smarts pattern provided as a matching substructure: {INVALID}" 17 | self.assertEqual(msg, str(context.exception)) 18 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/scoring_components/test_matching_substructures_not_provided.py: -------------------------------------------------------------------------------- 1 | import numpy.testing as npt 2 | 3 | from reinvent_scoring import MatchingSubstructure 4 | from unittest_reinvent.fixtures.test_data import METAMIZOLE 5 | from unittest_reinvent.scoring_tests.scoring_components.base_matching_substructure import \ 6 | BaseTestMatchingSubstructure 7 | from unittest_reinvent.scoring_tests.scoring_components.fixtures import score_single 8 | 9 | 10 | class TestMatchingSubstructuresNotProvided(BaseTestMatchingSubstructure): 11 | 12 | def setUp(self): 13 | self.smiles = [] 14 | super().setUp() 15 | self.component = MatchingSubstructure(self.parameters) 16 | 17 | def test_match_no_structure_1(self): 18 | npt.assert_almost_equal(score_single(self.component, METAMIZOLE), 1.0) 19 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/scoring_functions/test_custom_sum_matching_substructure_not_provided.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.fixtures.test_data import PROPANE 2 | from unittest_reinvent.scoring_tests.scoring_functions.base_test_custom_sum import BaseTestCustomSum 3 | 4 | 5 | class TestMatchingSubstructuresNotProvided(BaseTestCustomSum): 6 | 7 | def setUp(self): 8 | super().setup_attrs() 9 | super().init(self.sf_enum.MATCHING_SUBSTRUCTURE, "matching_substructure") 10 | super().setUp() 11 | 12 | def test_match_no_structure_1(self): 13 | score = self.sf_state.get_final_score(smiles=[PROPANE]) 14 | for i, s in enumerate(score.total_score): 15 | self.assertEqual(score.total_score[i], 1.) 16 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/scoring_functions/test_primary_mult_with_alert_no_sigm_trans.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.fixtures.test_data import PENTANE, BENZENE, CELECOXIB 2 | from unittest_reinvent.scoring_tests.scoring_functions.base_test_primary_multiplicative import BaseTestPrimaryMultiplicative 3 | 4 | 5 | class TestPrimaryMultWithAlertNoSigmTrans(BaseTestPrimaryMultiplicative): 6 | 7 | def setUp(self): 8 | smiles_2 = [PENTANE] 9 | smiles_3 = [BENZENE] 10 | super().init(smiles_2=smiles_2, smiles_3=smiles_3) 11 | super().setUp() 12 | 13 | def test_primary_mult_with_alert_no_transform_1(self): 14 | score = self.sf_state.get_final_score(smiles=[PENTANE]) 15 | self.assertEqual(score.total_score, 0) 16 | 17 | def test_primary_mult_with_alert_no_transform_2(self): 18 | score = self.sf_state.get_final_score(smiles=[CELECOXIB]) 19 | self.assertAlmostEqual(score.total_score[0], 0.337, 3) 20 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/scoring_functions/test_primary_mult_with_prediction_classification_and_regression.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.fixtures.test_data import CELECOXIB, BENZENE, PENTANE 2 | from unittest_reinvent.scoring_tests.scoring_functions.base_test_primary_multiplicative import BaseTestPrimaryMultiplicative 3 | 4 | 5 | class TestPrimaryMultWithPredictionClassificationAndRegressionAlert(BaseTestPrimaryMultiplicative): 6 | 7 | def setUp(self): 8 | smiles_2 = [PENTANE] 9 | smiles_3 = [BENZENE] 10 | super().init(smiles_2=smiles_2, smiles_3=smiles_3) 11 | super().setUp() 12 | 13 | def test_primary_mult_with_reg_class_1(self): 14 | score = self.sf_state.get_final_score(smiles=[CELECOXIB]) 15 | self.assertAlmostEqual(score.total_score[0], 0.337, 3) 16 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/scoring_functions/test_primary_multiplicative_function.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.fixtures.test_data import CELECOXIB, ASPIRIN, BENZENE 2 | from unittest_reinvent.scoring_tests.scoring_functions.base_test_primary_multiplicative import BaseTestPrimaryMultiplicative 3 | 4 | 5 | class TestPrimaryMultiplicativeFunction(BaseTestPrimaryMultiplicative): 6 | 7 | def setUp(self): 8 | smiles_3 = [BENZENE] 9 | super().init(smiles_3=smiles_3) 10 | super().setUp() 11 | 12 | def test_primary_multiplicative_1(self): 13 | score = self.sf_state.get_final_score(smiles=[CELECOXIB]) 14 | self.assertAlmostEqual(score.total_score[0], 0.337, 3) 15 | 16 | def test_primary_multiplicative_2(self): 17 | score = self.sf_state.get_final_score(smiles=[ASPIRIN]) 18 | self.assertAlmostEqual(score.total_score[0], 0.288, 3) 19 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/scoring_functions/test_primary_multiplicative_with_alert.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.fixtures.test_data import CELECOXIB, BENZENE, PENTANE 2 | from unittest_reinvent.scoring_tests.scoring_functions.base_test_primary_multiplicative import BaseTestPrimaryMultiplicative 3 | 4 | 5 | class TestPrimaryMultiplicativeWithAlert(BaseTestPrimaryMultiplicative): 6 | 7 | def setUp(self): 8 | smiles_2 = [PENTANE] 9 | smiles_3 = [BENZENE] 10 | super().init(smiles_2=smiles_2, smiles_3=smiles_3) 11 | super().setUp() 12 | 13 | def test_primary_mult_with_alert_1(self): 14 | score = self.sf_state.get_final_score(smiles=[PENTANE]) 15 | self.assertEqual(score.total_score, 0) 16 | 17 | def test_primary_mult_with_alert_2(self): 18 | score = self.sf_state.get_final_score(smiles=[CELECOXIB]) 19 | self.assertAlmostEqual(score.total_score[0], 0.337, 3) 20 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/scoring_transformations/fixtures.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | def round_list(lst: List[float], decimals: int) -> List[float]: 4 | return list(map(lambda x: round(x, decimals), lst)) 5 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/scoring_transformations/test_score_step_transformation.py: -------------------------------------------------------------------------------- 1 | from reinvent_scoring.scoring.enums import TransformationParametersEnum 2 | from unittest_reinvent.scoring_tests.scoring_transformations.base_test_score_transformations import BaseTestScoreTransformation 3 | 4 | 5 | class TestScoreStepTransformation(BaseTestScoreTransformation): 6 | 7 | def setUp(self): 8 | super().setup_attrs() 9 | specific_parameters = { 10 | self.csp_enum.TRANSFORMATION: { 11 | TransformationParametersEnum.HIGH: 14, 12 | TransformationParametersEnum.TRANSFORMATION_TYPE: self.tt_enum.STEP 13 | } 14 | } 15 | super().init(specific_parameters) 16 | super().setUp() 17 | 18 | def test_step_transformation(self): 19 | self.assertListEqual([1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0], self.transformed_scores.tolist()) 20 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/structural/__init__.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.scoring_tests.structural.test_azdock import Test_structural_AZdock 2 | from unittest_reinvent.scoring_tests.structural.test_dockstream import Test_structural_DockStream 3 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/scoring_tests/synthetic_accessibility/__init__.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.scoring_tests.synthetic_accessibility.test_sas_component import Test_sas_component 2 | -------------------------------------------------------------------------------- /reinvent/reinvent_scoring/unittest_reinvent/unit_testing.py: -------------------------------------------------------------------------------- 1 | import warnings 2 | 3 | 4 | def ignore_warnings(test_func): 5 | def do_test(self, *args, **kwargs): 6 | with warnings.catch_warnings(): 7 | warnings.simplefilter("ignore") 8 | test_func(self, *args, **kwargs) 9 | 10 | return do_test 11 | -------------------------------------------------------------------------------- /reinvent/reinventcli/.dockerignore: -------------------------------------------------------------------------------- 1 | **/.git 2 | build 3 | 4 | # Python 5 | **/.pytest_cache 6 | **/__pycache__ 7 | -------------------------------------------------------------------------------- /reinvent/reinventcli/.gitignore: -------------------------------------------------------------------------------- 1 | __pycache__ 2 | *.pyc 3 | package.json 4 | .vscode 5 | tags 6 | .idea 7 | /configs/config.json 8 | 9 | # Coverage.py output 10 | .coverage 11 | htmlcov/ 12 | 13 | # Python memory_profiler output 14 | mprofile_*.dat 15 | azdock_run.log 16 | 17 | # test related configurations 18 | unittest_reinvent/fixtures/integration_tests_config.json -------------------------------------------------------------------------------- /reinvent/reinventcli/Dockerfile: -------------------------------------------------------------------------------- 1 | FROM 378255172879.dkr.ecr.eu-west-1.amazonaws.com/docker.io/continuumio/conda-ci-linux-64-python3.7:01.08.2021 2 | 3 | USER root 4 | 5 | RUN apt-get update && \ 6 | apt-get -y install rsync procps && \ 7 | 8 | tar xf lua-5.1.4.9.tar.bz2 && \ 9 | cd lua-5.1.4.9 && \ 10 | 11 | make; make install && \ 12 | 13 | 14 | 15 | 16 | tar xf Lmod-8.2.tar.bz2 && \ 17 | 18 | make install && \ 19 | 20 | apt-get autoremove -y && \ 21 | apt-get clean 22 | 23 | 24 | 25 | LMOD_VERSION=8.2 \ 26 | 27 | 28 | 29 | USER=reinvent 30 | 31 | RUN adduser --disabled-password \ 32 | --uid 1000 \ 33 | --gid 100 \ 34 | --home /home/$USER \ 35 | $USER 36 | 37 | COPY . /reinventcli/ 38 | 39 | WORKDIR /reinventcli 40 | 41 | RUN conda env update --name=base --file=reinvent.yml && \ 42 | conda clean -afy && \ 43 | chmod -R "a+rx" /reinventcli 44 | 45 | USER reinvent 46 | -------------------------------------------------------------------------------- /reinvent/reinventcli/__init__.py: -------------------------------------------------------------------------------- 1 | # coding=utf-8 2 | -------------------------------------------------------------------------------- /reinvent/reinventcli/configs/sample_inputs/create_model.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": "2.0", 3 | "run_type": "create_model", 4 | "parameters": { 5 | 6 | 7 | "num_layers": 3, 8 | "layer_size": 512, 9 | "cell_type": "lstm", 10 | "embedding_layer_size": 256, 11 | "dropout": 0, 12 | "max_sequence_length": 256, 13 | "layer_normalization": false, 14 | "standardize": 0 15 | }, 16 | "logging": { 17 | "sender": "http://10.59.162.10:8081", 18 | "recipient": "local", 19 | 20 | "job_name": "test_job" 21 | } 22 | } -------------------------------------------------------------------------------- /reinvent/reinventcli/configs/sample_inputs/input.slurm.v2.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -l 2 | #SBATCH -N 1 3 | #SBATCH -c 4 4 | #SBATCH --mem=28G 5 | #SBATCH --time=100:0:0 6 | #SBATCH -p gpu 7 | #SBATCH --gres=gpu:1 8 | 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /reinvent/reinventcli/configs/sample_inputs/link_invent_create_model.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": "3.0", 3 | "run_type": "create_model", 4 | "model_type": "link_invent", 5 | "logging": { 6 | "recipient": "local", 7 | "logging_path": "/home", 8 | }, 9 | "parameters": { 10 | 11 | 12 | } 13 | } -------------------------------------------------------------------------------- /reinvent/reinventcli/configs/sample_inputs/molformer_create_model.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": "2.0", 3 | "run_type": "create_model", 4 | "model_type": "molformer", 5 | "parameters": { 6 | 7 | 8 | "max_sequence_length": 128, 9 | "use_cuda": true, 10 | "network":{ 11 | "num_layers": 6, 12 | "num_heads": 8, 13 | "model_dimension": 256, 14 | "feedforward_dimension": 2048, 15 | "dropout": 0.1 16 | } 17 | }, 18 | "logging": { 19 | "sender": "http://127.0.0.1", 20 | "recipient": "local", 21 | 22 | "job_name": "test_job", 23 | 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /reinvent/reinventcli/configs/sample_inputs/molformer_create_model_ranking.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": "2.0", 3 | "run_type": "create_model", 4 | "model_type": "molformer", 5 | "parameters": { 6 | "output_model_path": "../artifacts/results/ranking/high_similarity/empty_model.chpt", 7 | "input_smiles_path": "../datasets/high_similarity/smiles.csv", 8 | "max_sequence_length": 128, 9 | "use_cuda": true, 10 | "network":{ 11 | "num_layers": 6, 12 | "num_heads": 8, 13 | "model_dimension": 256, 14 | "feedforward_dimension": 2048, 15 | "dropout": 0.1 16 | } 17 | }, 18 | "logging": { 19 | "sender": "http://127.0.0.1", 20 | "recipient": "local", 21 | "logging_path": "../artifacts/results/ranking/high_similarity/progress.log", 22 | "job_name": "test_job", 23 | "result_folder": "../artifacts/results/ranking/high_similarity" 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /reinvent/reinventcli/configs/sample_inputs/molformer_transfer_learning.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": "2.0", 3 | "run_type": "transfer_learning", 4 | "model_type": "molformer", 5 | "parameters": { 6 | 7 | 8 | 9 | "validation_percentage": 0.1, 10 | "reset_optimizer": true, 11 | "pairs": 12 | { 13 | "type": "tanimoto", 14 | "threshold": 0.7, 15 | "min_cardinality": 10, 16 | "max_cardinality": 100 17 | }, 18 | "optimizer": { 19 | "lr": 1e-4, 20 | "beta1": 0.9, 21 | "beta2":0.98, 22 | "eps": 1e-9, 23 | "factor": 1.0, 24 | "warmup": 4000 25 | }, 26 | "starting_epoch": 1, 27 | "num_epochs": 60, 28 | "batch_size": 128, 29 | "shuffle_each_epoch": true, 30 | "save_every_n_epochs": 1 31 | }, 32 | "logging": { 33 | "sender": "http://127.0.0.1", 34 | "recipient": "local", 35 | 36 | "use_weights": 0, 37 | "job_name": "test_job", 38 | "job_id": "1" 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /reinvent/reinventcli/configs/sample_inputs/rocs_input.v2.slurm: -------------------------------------------------------------------------------- 1 | #!/bin/bash -l 2 | #SBATCH -N 1 3 | #SBATCH -c 4 4 | #SBATCH --mem=44G 5 | #SBATCH --time=100:0:0 6 | #SBATCH -p gpu 7 | #SBATCH --gres=gpu:1 8 | 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /reinvent/reinventcli/configs/sample_inputs/sampling.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": "2.0", 3 | "run_type": "sampling", 4 | "parameters": { 5 | 6 | 7 | "num_smiles": 1024, 8 | "batch_size": 128, 9 | "with_likelihood": false 10 | }, 11 | "logging": { 12 | "sender": "http://10.59.162.10:8081", 13 | "recipient": "local", 14 | 15 | "job_name": "test_job" 16 | } 17 | } -------------------------------------------------------------------------------- /reinvent/reinventcli/configs/sample_inputs/sampling_molformer.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": "3.0", 3 | "run_type": "sampling", 4 | "model_type": "molformer", 5 | "parameters": { 6 | 7 | 8 | "num_smiles": 100, 9 | "batch_size": 128, 10 | "with_likelihood": true, 11 | "sampling_strategy": "beamsearch", 12 | "drop_duplicate": true, 13 | "input": ["COC(c1ccc(NC(=O)[C@@H]2c3ccc(S(C)(=O)=O)cc3CN2C(C)=O)cc1)(C(F)(F)F)C(F)(F)F"], 14 | "parameters": { 15 | "temperature": 1.0, 16 | "target_smiles_path": "" 17 | } 18 | }, 19 | "logging": { 20 | "sender": "http://127.0.0.1", 21 | "recipient": "local", 22 | 23 | "job_name": "test_job" 24 | } 25 | } -------------------------------------------------------------------------------- /reinvent/reinventcli/configs/sample_inputs/transfer_learning.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": "2.0", 3 | "run_type": "transfer_learning", 4 | "parameters": { 5 | 6 | 7 | 8 | "save_every_n_epochs": 1, 9 | "batch_size": 128, 10 | "clip_gradient_norm": 1.0, 11 | "num_epochs": 5, 12 | "starting_epoch": 1, 13 | "shuffle_each_epoch": 1, 14 | "collect_stats_frequency": 1, 15 | "standardize": true, 16 | "randomize": false, 17 | 18 | "adaptive_lr_config": { 19 | "mode": "constant", 20 | "gamma": 0.8, 21 | "step": 1, 22 | "start": 5E-4, 23 | "min": 1E-5, 24 | "threshold": 1E-4, 25 | "average_steps": 4, 26 | "patience": 8, 27 | "restart_value": 1E-5, 28 | "sample_size": 100, 29 | "restart_times": 0 30 | } 31 | }, 32 | "logging": { 33 | "sender": "http://10.59.162.10:8081", 34 | "recipient": "local", 35 | 36 | "use_weights": 0, 37 | "job_name": "test_job", 38 | "job_id": "1" 39 | } 40 | } -------------------------------------------------------------------------------- /reinvent/reinventcli/configs/sample_inputs/validation.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": "2.0", 3 | "run_type": "validation", 4 | "logging": { 5 | "sender": "http://10.59.162.10:8081", 6 | "recipient": "local", 7 | 8 | "job_name": "test_job", 9 | "job_id": "1" 10 | }, 11 | "parameters": { 12 | "component_type": "activity", 13 | "name": "AXL_score", 14 | "weight": 2, 15 | 16 | "smiles": [], 17 | "specific_parameters": { 18 | "high": 9.0, 19 | "k": 0.25, 20 | "low": 4.0, 21 | "transformation_type": "sigmoid", 22 | "scikit": "regression", 23 | "transformation": false 24 | } 25 | } 26 | } -------------------------------------------------------------------------------- /reinvent/reinventcli/pytest.ini: -------------------------------------------------------------------------------- 1 | [pytest] 2 | markers = 3 | integration: mark a test as an integration test. 4 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/automated_curriculum_learning/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/automated_curriculum_learning/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/automated_curriculum_learning/actions/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.automated_curriculum_learning.actions.base_action import BaseAction 2 | from running_modes.automated_curriculum_learning.actions.base_sample_action import BaseSampleAction 3 | from running_modes.automated_curriculum_learning.actions.lib_invent_sample_model import LibInventSampleModel 4 | from running_modes.automated_curriculum_learning.actions.link_invent_sample_model import LinkInventSampleModel 5 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/automated_curriculum_learning/actions/base_action.py: -------------------------------------------------------------------------------- 1 | import abc 2 | from running_modes.automated_curriculum_learning.logging.base_logger import BaseLogger 3 | 4 | 5 | class BaseAction(abc.ABC): 6 | def __init__(self, logger=None): 7 | """ 8 | (Abstract) Initializes an action. 9 | :param logger: An optional logger instance. 10 | """ 11 | self.logger: BaseLogger = logger 12 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/automated_curriculum_learning/actions/base_sample_action.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | from running_modes.automated_curriculum_learning.actions import BaseAction 3 | 4 | 5 | class BaseSampleAction(BaseAction): 6 | 7 | def _get_indices_of_unique_smiles(self, smiles: [str]) -> np.array: 8 | """Returns an np.array of indices corresponding to the first entries in a list of smiles strings""" 9 | _, idxs = np.unique(smiles, return_index=True) 10 | sorted_indices = np.sort(idxs) 11 | return sorted_indices -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/automated_curriculum_learning/curriculum_strategy/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/automated_curriculum_learning/curriculum_strategy/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/automated_curriculum_learning/dto/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.automated_curriculum_learning.dto.curriculum_outcome_dto import CurriculumOutcomeDTO 2 | from running_modes.automated_curriculum_learning.dto.sampled_batch_dto import SampledBatchDTO 3 | from running_modes.automated_curriculum_learning.dto.sampled_sequences_dto import SampledSequencesDTO 4 | from running_modes.automated_curriculum_learning.dto.timestep_dto import TimestepDTO 5 | from running_modes.automated_curriculum_learning.dto.updated_likelihoods_dto import UpdatedLikelihoodsDTO 6 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/automated_curriculum_learning/dto/curriculum_outcome_dto.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from reinvent_models.model_factory.generative_model_base import GenerativeModelBase 3 | 4 | 5 | @dataclass 6 | class CurriculumOutcomeDTO: 7 | agent: GenerativeModelBase 8 | step_counter: int 9 | successful_curriculum: bool 10 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/automated_curriculum_learning/dto/sampled_batch_dto.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from typing import List 3 | 4 | import numpy as np 5 | import torch 6 | 7 | 8 | @dataclass 9 | class SampledBatchDTO: 10 | sequences: torch.Tensor 11 | smiles: List[str] 12 | likelihoods: torch.Tensor 13 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/automated_curriculum_learning/dto/sampled_sequences_dto.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass 5 | class SampledSequencesDTO: 6 | input: str 7 | output: str 8 | nll: float 9 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/automated_curriculum_learning/dto/timestep_dto.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | import torch 4 | from reinvent_scoring.scoring import FinalSummary 5 | 6 | 7 | @dataclass 8 | class TimestepDTO: 9 | start_time: float 10 | n_steps: int 11 | step: int 12 | score_summary: FinalSummary 13 | agent_likelihood: torch.tensor 14 | prior_likelihood: torch.tensor 15 | augmented_likelihood: torch.tensor -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/automated_curriculum_learning/dto/updated_likelihoods_dto.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | import torch 3 | 4 | 5 | @dataclass 6 | class UpdatedLikelihoodsDTO: 7 | agent_likelihood: torch.Tensor 8 | prior_likelihood: torch.Tensor 9 | augmented_likelihood: torch.Tensor 10 | loss: torch.Tensor -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/automated_curriculum_learning/inception/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/automated_curriculum_learning/inception/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/automated_curriculum_learning/learning_strategy/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.automated_curriculum_learning.learning_strategy.dap_molformer_strategy import DAPMolformerStrategy 2 | from running_modes.automated_curriculum_learning.learning_strategy.dap_single_query_strategy import \ 3 | DAPSingleQueryStrategy 4 | from running_modes.automated_curriculum_learning.learning_strategy.dap_strategy import DAPStrategy 5 | from running_modes.automated_curriculum_learning.learning_strategy.mascof_strategy import MASCOFStrategy 6 | from running_modes.automated_curriculum_learning.learning_strategy.mauli_strategy import MAULIStrategy 7 | from running_modes.automated_curriculum_learning.learning_strategy.sdap_strategy import SDAPStrategy 8 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/automated_curriculum_learning/learning_strategy/learning_strategy_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | from running_modes.automated_curriculum_learning.learning_strategy.learning_strategy_enum import LearningStrategyEnum 4 | 5 | 6 | @dataclass 7 | class LearningStrategyConfiguration: 8 | name: str = LearningStrategyEnum().DAP_SINGLE_QUERY 9 | parameters: dict = None 10 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/automated_curriculum_learning/learning_strategy/learning_strategy_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class LearningStrategyEnum: 6 | DAP = "dap" 7 | MAULI = "mauli" 8 | MASCOF = "mascof" 9 | SDAP = "sdap" 10 | DAP_SINGLE_QUERY = "dap_single_query" 11 | DAP_MOLFORMER = "dap_molformer" 12 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/automated_curriculum_learning/logging/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.automated_curriculum_learning.logging.console_message import ConsoleMessage 2 | from running_modes.automated_curriculum_learning.logging.auto_cl_logger import AutoCLLogger 3 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.automated_curriculum_learning import * 2 | from running_modes.configurations.compound_sampling import * 3 | from running_modes.configurations.create_model import * 4 | from running_modes.configurations.general_configuration_envelope import * 5 | from running_modes.configurations.logging import * 6 | from running_modes.configurations.reinforcement_learning import * 7 | from running_modes.configurations.scoring import ScoringRunnerComponents, ScoringRunnerConfiguration 8 | from running_modes.configurations.transfer_learning import * -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/automated_curriculum_learning/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.automated_curriculum_learning.automated_curriculum_learning_input_configuration import \ 2 | AutomatedCurriculumLearningInputConfiguration 3 | from running_modes.configurations.automated_curriculum_learning.curriculum_strategy_configuration import \ 4 | CurriculumStrategyConfiguration 5 | from running_modes.configurations.automated_curriculum_learning.curriculum_strategy_input_configuration import \ 6 | CurriculumStrategyInputConfiguration 7 | from running_modes.configurations.automated_curriculum_learning.inception_configuration import InceptionConfiguration 8 | from running_modes.configurations.automated_curriculum_learning.automated_curriculum_learning_configuration import \ 9 | AutomatedCLConfiguration 10 | from running_modes.configurations.automated_curriculum_learning.prodcution_strategy_input_configuration import \ 11 | ProductionStrategyInputConfiguration 12 | 13 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/automated_curriculum_learning/automated_curriculum_learning_configuration.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.automated_curriculum_learning.base_configuration import BaseConfiguration 2 | from running_modes.configurations.automated_curriculum_learning.curriculum_strategy_configuration import \ 3 | CurriculumStrategyConfiguration 4 | from running_modes.configurations.automated_curriculum_learning.production_strategy_configuration import \ 5 | ProductionStrategyConfiguration 6 | 7 | 8 | class AutomatedCLConfiguration(BaseConfiguration): 9 | prior: str 10 | agent: str 11 | curriculum_strategy: CurriculumStrategyConfiguration 12 | production_strategy: ProductionStrategyConfiguration 13 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/automated_curriculum_learning/automated_curriculum_learning_linkinvent_configuration.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.automated_curriculum_learning.base_configuration import BaseConfiguration 2 | from running_modes.configurations.automated_curriculum_learning.linkinvent_curriculum_strategy_configuration import \ 3 | LinkInventCurriculumStrategyConfiguration 4 | from running_modes.configurations.automated_curriculum_learning.linkinvent_production_strategy_configuration import \ 5 | LinkInventProductionStrategyConfiguration 6 | 7 | 8 | class AutomatedCurriculumLearningLinkInventConfiguration(BaseConfiguration): 9 | agent: str 10 | prior: str 11 | curriculum_strategy: LinkInventCurriculumStrategyConfiguration 12 | production_strategy: LinkInventProductionStrategyConfiguration -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/automated_curriculum_learning/base_configuration.py: -------------------------------------------------------------------------------- 1 | from pydantic import BaseModel 2 | 3 | 4 | class BaseConfiguration(BaseModel): 5 | curriculum_type: str -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/automated_curriculum_learning/curriculum_objective.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | from reinvent_scoring import ScoringFunctionParameters 4 | 5 | 6 | @dataclass 7 | class CurriculumObjective: 8 | scoring_function: ScoringFunctionParameters 9 | score_threshold: float = 0.4 10 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/automated_curriculum_learning/inception_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from typing import List 3 | from pydantic import Field 4 | 5 | 6 | @dataclass 7 | class InceptionConfiguration: 8 | memory_size: int = 100 9 | sample_size: int = 10 10 | smiles: List[str] = Field(default_factory=list) 11 | # inputs: List[str] = Field(default_factory=list) 12 | 13 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/compound_sampling/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.compound_sampling.sample_from_model_configuration import SampleFromModelConfiguration 2 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/compound_sampling/multinomial_sampling_configuration.py: -------------------------------------------------------------------------------- 1 | from pydantic import BaseModel 2 | 3 | 4 | class MultinomialSamplingConfiguration(BaseModel): 5 | temperature: float = 1.0 -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/compound_sampling/sample_from_model_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass, field 2 | from typing import List, Dict, Any 3 | 4 | from reinvent_models.molformer.enums import SamplingModesEnum 5 | 6 | 7 | @dataclass 8 | class SampleFromModelConfiguration: 9 | model_path: str 10 | output_smiles_path: str 11 | num_smiles: int = 1024 12 | batch_size: int = 128 13 | with_likelihood: bool = True 14 | sampling_strategy: str = SamplingModesEnum.BEAMSEARCH 15 | drop_duplicate: bool = True 16 | input: List[str] = field(default_factory=list) 17 | parameters: Dict[str, Any] = field(default_factory=dict) 18 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/create_model/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.create_model.create_model_configuration import CreateModelConfiguration 2 | from running_modes.configurations.create_model.link_invent_create_model_configuration import \ 3 | LinkInventCreateModelConfiguration 4 | from running_modes.configurations.create_model.molformer_create_model_configuration import \ 5 | MolformerCreateModelConfiguration 6 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/create_model/create_model_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass 5 | class CreateModelConfiguration: 6 | input_smiles_path: str 7 | output_model_path: str 8 | num_layers: int = 3 9 | layer_size: int = 512 10 | cell_type: str = 'lstm' 11 | embedding_layer_size: int = 256 12 | dropout: float = 0. 13 | max_sequence_length: int = 256 14 | layer_normalization: bool = False 15 | standardize: bool = False 16 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/create_model/link_invent_create_model_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass 5 | class LinkInventCreateModelConfiguration: 6 | input_smiles_path: str 7 | output_model_path: str 8 | num_layers: int = 3 9 | layer_size: int = 512 10 | embedding_layer_size: int = 256 11 | dropout: float = 0 12 | layer_normalisation: bool = False 13 | max_sequence_length: int = 256 14 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/create_model/molformer_create_model_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | from reinvent_models.molformer.dto.molformer_model_parameters_dto import MolformerNetworkParameters 4 | 5 | @dataclass 6 | class MolformerCreateModelConfiguration: 7 | input_smiles_path: str 8 | output_model_path: str 9 | network: MolformerNetworkParameters 10 | max_sequence_length: int = 128 11 | use_cuda: bool = True 12 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/curriculum_learning/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.curriculum_learning.curriculum_learning_components import CurriculumLearningComponents 2 | from running_modes.configurations.curriculum_learning.curriculum_learning_configuration import CurriculumLearningConfiguration 3 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/curriculum_learning/curriculum_learning_components.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.automated_curriculum_learning.base_configuration import BaseConfiguration 2 | 3 | 4 | class CurriculumLearningComponents(BaseConfiguration): 5 | """This class holds the necessary configuration components to run CL""" 6 | curriculum_learning: dict 7 | scoring_function: dict 8 | diversity_filter: dict 9 | inception: dict 10 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/curriculum_learning/curriculum_learning_configuration.py: -------------------------------------------------------------------------------- 1 | from pydantic import BaseModel 2 | 3 | 4 | class CurriculumLearningConfiguration(BaseModel): 5 | prior: str 6 | agent: str 7 | update_lock: str 8 | general_configuration_path: str 9 | pause_lock: str = '' 10 | pause_limit: int = 5 11 | n_steps: int = 3000 12 | sigma: int = 120 13 | learning_rate: float = 0.0001 14 | batch_size: int = 128 15 | reset: int = 0 16 | reset_score_cutoff: float = 0.5 17 | margin_threshold: int = 50 18 | distance_threshold: float = -100.0 19 | scheduled_update_step: int = 0 20 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/general_configuration_envelope.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | from running_modes.enums.model_type_enum import ModelTypeEnum 4 | 5 | 6 | @dataclass 7 | class GeneralConfigurationEnvelope: 8 | parameters: dict 9 | logging: dict 10 | run_type: str 11 | version: str 12 | model_type: str = ModelTypeEnum().DEFAULT 13 | 14 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/logging/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.logging.base_log_config import BaseLoggerConfiguration 2 | from running_modes.configurations.logging.create_model_log_configuration import CreateModelLoggerConfiguration 3 | from running_modes.configurations.logging.curriculum_log_configuration import CurriculumLoggerConfiguration 4 | from running_modes.configurations.logging.reinforcement_log_configuration import ReinforcementLoggerConfiguration 5 | from running_modes.configurations.logging.sampling_log_configuration import SamplingLoggerConfiguration 6 | from running_modes.configurations.logging.scoring_log_configuration import ScoringLoggerConfiguration 7 | from running_modes.configurations.logging.transfer_learning_log_configuration import TransferLearningLoggerConfig 8 | from running_modes.configurations.logging.remote_logging import get_remote_logging_auth_token 9 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/logging/base_log_config.py: -------------------------------------------------------------------------------- 1 | from typing import Optional 2 | from pydantic import BaseModel 3 | 4 | 5 | class BaseLoggerConfiguration(BaseModel): 6 | recipient: str 7 | logging_path: str 8 | sender: str = "" 9 | job_name: str = "default_name" 10 | job_id: Optional[str] = "" 11 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/logging/create_model_log_configuration.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.logging.base_log_config import BaseLoggerConfiguration 2 | 3 | 4 | class CreateModelLoggerConfiguration(BaseLoggerConfiguration): 5 | pass 6 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/logging/curriculum_log_configuration.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.logging.base_log_config import BaseLoggerConfiguration 2 | 3 | 4 | class CurriculumLoggerConfiguration(BaseLoggerConfiguration): 5 | result_folder: str 6 | logging_frequency: int = 0 7 | # rows and columns define the shape of the output grid of molecule images in tensorboard. 8 | rows: int = 4 9 | columns: int = 4 10 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/logging/reinforcement_log_configuration.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.logging.base_log_config import BaseLoggerConfiguration 2 | 3 | 4 | class ReinforcementLoggerConfiguration(BaseLoggerConfiguration): 5 | result_folder: str 6 | logging_frequency: int = 0 7 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/logging/remote_logging.py: -------------------------------------------------------------------------------- 1 | import os 2 | 3 | 4 | def get_remote_logging_auth_token(): 5 | return os.getenv('REMOTE_LOGGING_AUTH_TOKEN') 6 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/logging/sampling_log_configuration.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.logging.base_log_config import BaseLoggerConfiguration 2 | 3 | 4 | class SamplingLoggerConfiguration(BaseLoggerConfiguration): 5 | pass 6 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/logging/scoring_log_configuration.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.logging.base_log_config import BaseLoggerConfiguration 2 | 3 | 4 | class ScoringLoggerConfiguration(BaseLoggerConfiguration): 5 | pass 6 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/logging/transfer_learning_log_configuration.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.logging.base_log_config import BaseLoggerConfiguration 2 | 3 | 4 | class TransferLearningLoggerConfig(BaseLoggerConfiguration): 5 | use_weights: bool = False 6 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/reinforcement_learning/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.reinforcement_learning.inception_configuration import InceptionConfiguration 2 | from running_modes.configurations.reinforcement_learning.reinforcement_learning_components import ReinforcementLearningComponents 3 | from running_modes.configurations.reinforcement_learning.reinforcement_learning_configuration import ReinforcementLearningConfiguration 4 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/reinforcement_learning/inception_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | from typing import List 4 | 5 | 6 | @dataclass 7 | class InceptionConfiguration: 8 | smiles: List[str] 9 | memory_size: int 10 | sample_size: int 11 | # self.update_size = update_size 12 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/reinforcement_learning/reinforcement_learning_components.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | from reinvent_scoring.scoring.diversity_filters.reinvent_core.diversity_filter_parameters import \ 4 | DiversityFilterParameters 5 | from reinvent_scoring.scoring.scoring_function_parameters import ScoringFunctionParameters 6 | 7 | from running_modes.configurations.reinforcement_learning.inception_configuration import InceptionConfiguration 8 | from running_modes.configurations.reinforcement_learning.reinforcement_learning_configuration import \ 9 | ReinforcementLearningConfiguration 10 | 11 | 12 | @dataclass 13 | class ReinforcementLearningComponents: 14 | """This class holds the necessary configuration components to run RL""" 15 | reinforcement_learning: ReinforcementLearningConfiguration 16 | scoring_function: ScoringFunctionParameters 17 | diversity_filter: DiversityFilterParameters 18 | inception: InceptionConfiguration 19 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/reinforcement_learning/reinforcement_learning_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass 5 | class ReinforcementLearningConfiguration: 6 | prior: str 7 | agent: str 8 | n_steps: int = 3000 9 | sigma: int = 120 10 | learning_rate: float = 0.0001 11 | batch_size: int = 128 12 | margin_threshold: int = 50 13 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/scoring/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.scoring.scoring_runner_components import ScoringRunnerComponents 2 | from running_modes.configurations.scoring.scoring_runner_configuration import ScoringRunnerConfiguration 3 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/scoring/scoring_runner_components.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | from reinvent_scoring.scoring import ScoringFunctionParameters 4 | 5 | from running_modes.configurations.scoring.scoring_runner_configuration import ScoringRunnerConfiguration 6 | 7 | 8 | @dataclass 9 | class ScoringRunnerComponents: 10 | """This class holds the necessary configuration components to do a scoring run.""" 11 | 12 | scoring: ScoringRunnerConfiguration 13 | scoring_function: ScoringFunctionParameters 14 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/scoring/scoring_runner_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass 5 | class ScoringRunnerConfiguration: 6 | 7 | input: str 8 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/transfer_learning/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.transfer_learning.adaptive_learning_rate_configuration import AdaptiveLearningRateConfiguration 2 | from running_modes.configurations.transfer_learning.link_invent_transfer_learning_configuration import \ 3 | LinkInventTransferLearningConfiguration 4 | from running_modes.configurations.transfer_learning.transfer_learning_configuration import TransferLearningConfiguration 5 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/transfer_learning/adaptive_learning_rate_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass 5 | class AdaptiveLearningRateConfiguration: 6 | mode: str = "constant" 7 | gamma: float = 0.8 8 | step: int = 1 9 | start: float = 5E-4 10 | min: float = 1E-5 11 | threshold: float = 1E-4 12 | average_steps: int = 4 13 | patience: int = 8 14 | restart_value: float = 1E-5 15 | sample_size: int = 100 16 | restart_times: int = 0 17 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/transfer_learning/link_invent_learning_rate_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass 5 | class LinkInventLearningRateConfiguration: 6 | start: float = 0.0001 7 | min: float = 0.000001 8 | gamma: float = 0.95 9 | step: int = 1 10 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/transfer_learning/link_invent_transfer_learning_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from typing import Optional 3 | 4 | from running_modes.configurations.transfer_learning.link_invent_learning_rate_configuration import \ 5 | LinkInventLearningRateConfiguration 6 | 7 | 8 | @dataclass 9 | class LinkInventTransferLearningConfiguration: 10 | empty_model: str 11 | learning_rate: LinkInventLearningRateConfiguration 12 | output_path: str 13 | input_smiles_path: str 14 | sample_size: int 15 | batch_size: int = 128 16 | starting_epoch: int = 1 17 | num_epochs: int = 10 18 | clip_gradient_norm: float = 10 19 | collect_stats_frequency: int = 1 20 | save_model_frequency: int = 1 21 | validation_smiles_path: Optional[str] = None 22 | with_weights: bool = False 23 | model_file_name = 'trained.model' 24 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/transfer_learning/molformer_transfer_learning_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from running_modes.configurations.transfer_learning.noamopt_configuration import NoamoptConfiguration 3 | 4 | #FIXME: pairs must be a configuration object not a generic dict 5 | 6 | @dataclass 7 | class MolformerTransferLearningConfiguration: 8 | input_model_path: str 9 | output_model_path: str 10 | input_smiles_path: str 11 | optimizer: NoamoptConfiguration 12 | pairs: dict 13 | reset_optimizer: bool = True 14 | ranking_loss_penalty: bool = False 15 | starting_epoch: int = 1 16 | num_epochs: int = 60 17 | batch_size: int = 128 18 | shuffle_each_epoch: bool = True 19 | save_every_n_epochs: int = 0 20 | validation_percentage: float = 0.0 21 | validation_seed: int = None 22 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/configurations/transfer_learning/noamopt_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | @dataclass 4 | class NoamoptConfiguration: 5 | lr: float = 1e-4 6 | beta1: float = 0.9 7 | beta2: float = 0.98 8 | eps: float = 1e-9 9 | factor: float = 1.0 10 | warmup: float = 4000 11 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/constructors/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/constructors/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/constructors/base_running_mode.py: -------------------------------------------------------------------------------- 1 | from abc import abstractmethod, ABC 2 | 3 | 4 | class BaseRunningMode(ABC): 5 | 6 | @abstractmethod 7 | def run(self): 8 | raise NotImplementedError("run method is not implemented") -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/constructors/scoring_mode_constructor.py: -------------------------------------------------------------------------------- 1 | from dacite import from_dict 2 | from reinvent_scoring.scoring import ScoringFunctionFactory 3 | 4 | from running_modes.constructors.base_running_mode import BaseRunningMode 5 | from running_modes.configurations import GeneralConfigurationEnvelope, ScoringRunnerComponents 6 | from running_modes.scoring.scoring_runner import ScoringRunner 7 | 8 | 9 | class ScoringModeConstructor: 10 | def __new__(self, configuration: GeneralConfigurationEnvelope) -> BaseRunningMode: 11 | self._configuration = configuration 12 | config = from_dict(data_class=ScoringRunnerComponents, data=self._configuration.parameters) 13 | scoring_function = ScoringFunctionFactory(config.scoring_function) 14 | runner = ScoringRunner(configuration=self._configuration, 15 | config=config.scoring, 16 | scoring_function=scoring_function) 17 | return runner -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/constructors/validation_mode_constructor.py: -------------------------------------------------------------------------------- 1 | from dacite import from_dict 2 | from reinvent_scoring.scoring import ComponentParameters 3 | 4 | from running_modes.constructors.base_running_mode import BaseRunningMode 5 | from running_modes.configurations import GeneralConfigurationEnvelope 6 | from running_modes.validation.validation_runner import ValidationRunner 7 | 8 | 9 | class ValidationModeConstructor: 10 | def __new__(self, configuration: GeneralConfigurationEnvelope) -> BaseRunningMode: 11 | self._configuration = configuration 12 | config = from_dict(data_class=ComponentParameters, data=self._configuration.parameters) 13 | runner = ValidationRunner(self._configuration, config) 14 | return runner -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/create_model/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.create_model.create_model import CreateModelRunner 2 | from running_modes.create_model.link_invent_create_model import LinkInventCreateModelRunner 3 | from running_modes.create_model.molformer_create_model import MolformerCreateModelRunner 4 | 5 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/create_model/logging/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/create_model/logging/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/create_model/logging/local_create_model_logger.py: -------------------------------------------------------------------------------- 1 | import json 2 | import os 3 | 4 | from running_modes.create_model.logging.base_create_model_logger import BaseCreateModelLogger 5 | 6 | 7 | class LocalCreateModelLogger(BaseCreateModelLogger): 8 | def log_message(self, message: str): 9 | self._common_logger.info(message) 10 | 11 | 12 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/curriculum_learning/logging/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.curriculum_learning.logging.base_curriculum_logger import BaseCurriculumLogger 2 | from running_modes.curriculum_learning.logging.curriculum_logger import CurriculumLogger 3 | from running_modes.curriculum_learning.logging.local_curriculum_logger import LocalCurriculumLogger 4 | from running_modes.curriculum_learning.logging.remote_curriculum_logger import RemoteCurriculumLogger 5 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/enums/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/enums/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/enums/adaptive_learning_rate_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class AdaptiveLearningRateEnum: 6 | EXPONENTIAL = "exponential" 7 | ADAPTIVE = "adaptive" 8 | CONSTANT = "constant" 9 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/enums/curriculum_strategy_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class CurriculumStrategyEnum: 6 | STANDARD = "standard" 7 | LINK_INVENT = "link_invent" 8 | MOLFORMER = "molformer" 9 | NO_CURRICULUM = "no_curriculum" 10 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/enums/curriculum_type_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class CurriculumType: 6 | AUTOMATED = "automated" 7 | MANUAL = "manual" 8 | 9 | CurriculumTypeEnum = CurriculumType() -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/enums/logging_mode_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class LoggingModeEnum: 6 | LOCAL = "local" 7 | REMOTE = "remote" 8 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/enums/merging_strategy_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class MergingStrategyEnum: 6 | LINEAR_MERGE = "linear" 7 | LINEAR_MERGE_WITH_THRESHOLD = "linear_with_threshold" 8 | LINEAR_MERGE_WITH_BULK = "linear_with_bulk" 9 | LINEAR_MERGE_WITH_REMOVAL = "linear_with_removal" 10 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/enums/model_type_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class ModelTypeEnum: 6 | DEFAULT = "default" 7 | LIB_INVENT = "lib_invent" 8 | LINK_INVENT = "link_invent" 9 | MOLFORMER = "molformer" 10 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/enums/production_strategy_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class ProductionStrategyEnum: 6 | STANDARD = "standard" 7 | SPECIFIC_COMPONENTS = "specific_components" 8 | LINK_INVENT = "link_invent" 9 | MOLFORMER = "molformer" -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/enums/ranking_strategy_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class RankingStrategyEnum: 6 | SEQUENTIAL_FIXED_TIME = "sequential_fixed_time" 7 | SEQUENTIAL_THRESHOLD = "sequential_threshold" 8 | USER_DEFINED_ORDER = "user_defined_order" -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/enums/running_mode_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class RunningModeEnum: 6 | TRANSFER_LEARNING = "transfer_learning" 7 | REINFORCEMENT_LEARNING = "reinforcement_learning" 8 | SAMPLING = "sampling" 9 | CREATE_MODEL = "create_model" 10 | VALIDATION = "validation" 11 | SCORING = "scoring" 12 | CURRICULUM_LEARNING = "curriculum_learning" 13 | LIB_INVENT_REINFORCEMENT_LEARNING = "lib_invent_reinforcement_learning" 14 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/enums/scoring_runner_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class ScoringRunnerEnum: 6 | 7 | SMILES = "smiles" 8 | TOTAL_SCORE = "total_score" 9 | VALID = "valid" 10 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/enums/scoring_table_enum.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass(frozen=True) 5 | class ScoringTableEnum: 6 | 7 | AGENTS = "agents" 8 | SCORES = "scores" 9 | SCORING_FUNCTIONS = "scoring_functions" 10 | COMPONENT_NAMES = "component_names" 11 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/manager.py: -------------------------------------------------------------------------------- 1 | import os 2 | 3 | from running_modes.configurations import GeneralConfigurationEnvelope 4 | from running_modes.constructors.running_mode import RunningMode 5 | from running_modes.enums.running_mode_enum import RunningModeEnum 6 | 7 | 8 | class Manager: 9 | def __init__(self, base_configuration, run_configuration): 10 | self.running_mode_enum = RunningModeEnum() 11 | self.base_configuration = base_configuration 12 | self.run_configuration = GeneralConfigurationEnvelope(**run_configuration) 13 | self._load_environmental_variables() 14 | self.runner = RunningMode(self.run_configuration) 15 | 16 | def run(self): 17 | self.runner.run() 18 | 19 | def _load_environmental_variables(self): 20 | environmental_variables = self.base_configuration["ENVIRONMENTAL_VARIABLES"] 21 | for key, value in environmental_variables.items(): 22 | os.environ[key] = value 23 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.reinforcement_learning.core_reinforcement_learning import CoreReinforcementRunner 2 | from running_modes.reinforcement_learning.inception import Inception 3 | from running_modes.reinforcement_learning.lib_invent_reinforcement_learning import LibInventReinforcementLearning 4 | from running_modes.reinforcement_learning.link_invent_reinforcement_learning import LinkInventReinforcementLearning 5 | 6 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/actions/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.reinforcement_learning.actions.base_action import BaseAction 2 | from running_modes.reinforcement_learning.actions.lib_invent_likelihood_evaluation import LikelihoodEvaluation 3 | from running_modes.reinforcement_learning.actions.lib_invent_sample_model import LibInventSampleModel 4 | from running_modes.reinforcement_learning.actions.link_invent_sample_model import LinkInventSampleModel 5 | from running_modes.reinforcement_learning.actions.link_invent_likelihood_evaluation import LinkInventLikelihoodEvaluation -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/actions/base_action.py: -------------------------------------------------------------------------------- 1 | import abc 2 | 3 | from running_modes.reinforcement_learning.logging.local_reinforcement_logger import LocalReinforcementLogger 4 | 5 | 6 | class BaseAction(abc.ABC): 7 | def __init__(self, logger=None): 8 | """ 9 | (Abstract) Initializes an action. 10 | :param logger: An optional logger instance. 11 | """ 12 | self.logger: LocalReinforcementLogger = logger 13 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/configurations/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.reinforcement_learning.configurations.lib_invent_reinforcement_learning_configuration import \ 2 | LibInventReinforcementLearningConfiguration 3 | from running_modes.reinforcement_learning.configurations.link_invent_log_configuration import LogConfiguration 4 | from running_modes.reinforcement_learning.configurations.link_invent_reinforcement_learning_configuration import \ 5 | LinkInventReinforcementLearningConfiguration 6 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/configurations/learning_strategy_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass 5 | class LearningStrategyConfiguration: 6 | name: str 7 | parameters: dict = None 8 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/configurations/lib_invent_reinforcement_learning_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from typing import List 3 | 4 | from running_modes.reinforcement_learning.configurations.learning_strategy_configuration import \ 5 | LearningStrategyConfiguration 6 | from running_modes.reinforcement_learning.configurations.lib_invent_scoring_strategy_configuration import \ 7 | LibInventScoringStrategyConfiguration 8 | 9 | 10 | @dataclass 11 | class LibInventReinforcementLearningConfiguration: 12 | actor: str 13 | critic: str 14 | scaffolds: List[str] 15 | learning_strategy: LearningStrategyConfiguration 16 | scoring_strategy: LibInventScoringStrategyConfiguration 17 | n_steps: int = 1000 18 | learning_rate: float = 0.0001 19 | batch_size: int = 128 20 | randomize_scaffolds: bool = False 21 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/configurations/lib_invent_scoring_strategy_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | from reinvent_chemistry.library_design.reaction_filters.reaction_filter_configruation import ReactionFilterConfiguration 4 | from reinvent_scoring.scoring.diversity_filters.reinvent_core.diversity_filter_parameters import \ 5 | DiversityFilterParameters 6 | 7 | from running_modes.reinforcement_learning.configurations.scoring_strategy_configuration import \ 8 | ScoringStrategyConfiguration 9 | 10 | 11 | @dataclass 12 | class LibInventScoringStrategyConfiguration(ScoringStrategyConfiguration): 13 | reaction_filter: ReactionFilterConfiguration 14 | diversity_filter: DiversityFilterParameters 15 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/configurations/link_invent_log_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass 5 | class LogConfiguration: 6 | logging_path: str 7 | sender: str = None 8 | recipient: str = "local" 9 | job_id: str = None 10 | job_name: str = "default_name" 11 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/configurations/link_invent_reinforcement_learning_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from typing import List 3 | 4 | from running_modes.reinforcement_learning.configurations.learning_strategy_configuration import \ 5 | LearningStrategyConfiguration 6 | from running_modes.reinforcement_learning.configurations.link_invent_scoring_strategy_congfiguration import \ 7 | LinkInventScoringStrategyConfiguration 8 | 9 | 10 | @dataclass 11 | class LinkInventReinforcementLearningConfiguration: 12 | actor: str 13 | critic: str 14 | warheads: List[str] 15 | learning_strategy: LearningStrategyConfiguration 16 | scoring_strategy: LinkInventScoringStrategyConfiguration 17 | n_steps: int = 1000 18 | learning_rate: float = 0.0001 19 | batch_size: int = 128 20 | randomize_warheads: bool = False 21 | 22 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/configurations/link_invent_scoring_strategy_congfiguration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from reinvent_scoring.scoring.diversity_filters.reinvent_core.diversity_filter_parameters import \ 3 | DiversityFilterParameters 4 | 5 | from running_modes.reinforcement_learning.configurations.scoring_strategy_configuration import \ 6 | ScoringStrategyConfiguration 7 | 8 | 9 | @dataclass 10 | class LinkInventScoringStrategyConfiguration(ScoringStrategyConfiguration): 11 | diversity_filter: DiversityFilterParameters 12 | 13 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/configurations/scoring_strategy_configuration.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | from reinvent_scoring import ScoringFunctionParameters 4 | 5 | 6 | @dataclass 7 | class ScoringStrategyConfiguration: 8 | scoring_function: ScoringFunctionParameters 9 | name: str 10 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/dto/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/reinforcement_learning/dto/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/dto/sampled_sequences_dto.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | 3 | 4 | @dataclass 5 | class SampledSequencesDTO: 6 | input: str 7 | output: str 8 | nll: float 9 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/learning_strategy/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.reinforcement_learning.learning_strategy.base_learning_strategy import BaseLearningStrategy 2 | from running_modes.reinforcement_learning.learning_strategy.dap_strategy import DAPStrategy 3 | from running_modes.reinforcement_learning.learning_strategy.learning_strategy_enum import LearningStrategyEnum 4 | from running_modes.reinforcement_learning.learning_strategy.mascof_strategy import MASCOFStrategy 5 | from running_modes.reinforcement_learning.learning_strategy.mauli_strategy import MAULIStrategy 6 | from running_modes.reinforcement_learning.learning_strategy.sdap_strategy import SDAPStrategy 7 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/learning_strategy/learning_strategy_enum.py: -------------------------------------------------------------------------------- 1 | class LearningStrategyEnum: 2 | DAP = "dap" 3 | MAULI = "mauli" 4 | MASCOF = "mascof" 5 | SDAP = "sdap" 6 | 7 | # try to find the internal value and return 8 | def __getattr__(self, name): 9 | if name in self: 10 | return name 11 | raise AttributeError 12 | 13 | # prohibit any attempt to set any values 14 | def __setattr__(self, key, value): 15 | raise ValueError("No changes allowed.") 16 | 17 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/logging/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.reinforcement_learning.logging.console_message import ConsoleMessage 2 | from running_modes.reinforcement_learning.logging.local_reinforcement_logger import LocalReinforcementLogger 3 | from running_modes.reinforcement_learning.logging.reinforcement_logger import ReinforcementLogger 4 | from running_modes.reinforcement_learning.logging.remote_reinforcement_logger import RemoteReinforcementLogger 5 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/logging/link_logging/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.reinforcement_learning.logging.link_logging.console_message import ConsoleMessage 2 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/scoring_strategy/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/reinforcement_learning/scoring_strategy/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/reinforcement_learning/scoring_strategy/scoring_strategy_enum.py: -------------------------------------------------------------------------------- 1 | class ScoringStrategyEnum: 2 | LINK_INVENT = "link_invent" 3 | LIB_INVENT = "lib_invent" 4 | 5 | # try to find the internal value and return 6 | def __getattr__(self, name): 7 | if name in self: 8 | return name 9 | raise AttributeError 10 | 11 | # prohibit any attempt to set any values 12 | def __setattr__(self, key, value): 13 | raise ValueError("No changes allowed.") 14 | 15 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/sampling/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/sampling/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/sampling/logging/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/sampling/logging/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/scoring/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/scoring/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/scoring/logging/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/scoring/logging/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/scoring/logging/local_scoring_logger.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.general_configuration_envelope import GeneralConfigurationEnvelope 2 | from running_modes.scoring.logging.base_scoring_logger import BaseScoringLogger 3 | from running_modes.enums.scoring_runner_enum import ScoringRunnerEnum 4 | 5 | 6 | class LocalScoringLogger(BaseScoringLogger): 7 | def __init__(self, configuration: GeneralConfigurationEnvelope): 8 | super().__init__(configuration) 9 | self._scoring_runner_enum = ScoringRunnerEnum() 10 | 11 | def log_message(self, message: str): 12 | self._logger.info(message) 13 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/scoring/logging/scoring_logger.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.general_configuration_envelope import GeneralConfigurationEnvelope 2 | from running_modes.configurations.logging.scoring_log_configuration import ScoringLoggerConfiguration 3 | from running_modes.scoring.logging.local_scoring_logger import LocalScoringLogger 4 | from running_modes.scoring.logging.remote_scoring_logger import RemoteScoringLogger 5 | from running_modes.enums.logging_mode_enum import LoggingModeEnum 6 | 7 | 8 | class ScoringLogger: 9 | 10 | def __new__(cls, configuration: GeneralConfigurationEnvelope): 11 | logging_mode_enum = LoggingModeEnum() 12 | scoring_config = ScoringLoggerConfiguration(**configuration.logging) 13 | if scoring_config.recipient == logging_mode_enum.LOCAL: 14 | logger = LocalScoringLogger(configuration) 15 | else: 16 | logger = RemoteScoringLogger(configuration) 17 | return logger 18 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/transfer_learning/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/transfer_learning/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/transfer_learning/dto/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/transfer_learning/dto/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/transfer_learning/dto/collected_stats_dto.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from typing import List 3 | 4 | from running_modes.transfer_learning.dto.sampled_stats_dto import SampledStatsDTO 5 | 6 | 7 | @dataclass 8 | class CollectedStatsDTO: 9 | jsd_binned: float 10 | jsd_un_binned: float 11 | nll: List[float] 12 | training_stats: SampledStatsDTO 13 | validation_nll: List[float] = None 14 | validation_stats: SampledStatsDTO = None 15 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/transfer_learning/dto/sampled_stats_dto.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from typing import List 3 | 4 | 5 | @dataclass 6 | class SampledStatsDTO: 7 | nll_input_sampled_target: List[float] 8 | molecule_smiles: List[str] 9 | molecule_parts_smiles: List[str] 10 | valid_fraction: float 11 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/transfer_learning/link_invent_actions/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/transfer_learning/link_invent_actions/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/transfer_learning/link_invent_actions/base_action.py: -------------------------------------------------------------------------------- 1 | from abc import ABC, abstractmethod 2 | 3 | from running_modes.transfer_learning.logging.base_transfer_learning_logger import BaseTransferLearningLogger 4 | 5 | 6 | class BaseAction(ABC): 7 | def __init__(self, logger): 8 | """ 9 | (Abstract) Initializes an action. 10 | :param logger: An optional logger instance. 11 | """ 12 | self._logger: BaseTransferLearningLogger = logger 13 | 14 | @abstractmethod 15 | def run(self): 16 | raise NotImplementedError('Method not implemented') 17 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/transfer_learning/logging/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/transfer_learning/logging/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/transfer_learning/optimizers/__init__.py: -------------------------------------------------------------------------------- 1 | from .noam import NoamOpt 2 | 3 | __all__ = ['NoamOpt'] -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/utils/__init__.py: -------------------------------------------------------------------------------- 1 | from running_modes.utils.configuration import _is_development_environment 2 | from running_modes.utils.general import to_tensor, set_default_device_cuda 3 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/utils/configuration.py: -------------------------------------------------------------------------------- 1 | import json 2 | import os 3 | 4 | 5 | def _is_development_environment() -> bool: 6 | return bool(os.environ.get("REINVENT_DEVELOPMENT_ENVIRONMENT")) 7 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/validation/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/validation/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/validation/logging/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/running_modes/validation/logging/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/validation/logging/local_validation_logger.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations.general_configuration_envelope import GeneralConfigurationEnvelope 2 | from running_modes.validation.logging.base_validation_logger import BaseValidationLogger 3 | 4 | 5 | class LocalValidationLogger(BaseValidationLogger): 6 | def __init__(self, configuration: GeneralConfigurationEnvelope): 7 | super().__init__(configuration) 8 | 9 | def log_message(self, message: str): 10 | self._common_logger.info(message) 11 | 12 | -------------------------------------------------------------------------------- /reinvent/reinventcli/running_modes/validation/logging/validation_logger.py: -------------------------------------------------------------------------------- 1 | from running_modes.configurations import GeneralConfigurationEnvelope, BaseLoggerConfiguration 2 | from running_modes.validation.logging.local_validation_logger import LocalValidationLogger 3 | from running_modes.validation.logging.remote_validation_logger import RemoteValidationLogger 4 | from running_modes.enums.logging_mode_enum import LoggingModeEnum 5 | 6 | 7 | class ValidationLogger: 8 | 9 | def __new__(cls, configuration: GeneralConfigurationEnvelope): 10 | logging_mode_enum = LoggingModeEnum() 11 | scoring_config = BaseLoggerConfiguration(**configuration.logging) 12 | if scoring_config.recipient == logging_mode_enum.LOCAL: 13 | logger = LocalValidationLogger(configuration) 14 | else: 15 | logger = RemoteValidationLogger(configuration) 16 | return logger 17 | -------------------------------------------------------------------------------- /reinvent/reinventcli/sonar-project.properties: -------------------------------------------------------------------------------- 1 | sonar.projectKey=admta-com-reinventcli -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/unittest_reinvent/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/fixtures/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/unittest_reinvent/fixtures/__init__.py -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/fixtures/dummy_regression_model.pkl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MolecularAI/reinforcement-learning-active-learning/92caa2fb11b9519307b433e489fbc97e71a217c2/reinvent/reinventcli/unittest_reinvent/fixtures/dummy_regression_model.pkl -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/fixtures/example.config.json: -------------------------------------------------------------------------------- 1 | { 2 | "ENVIRONMENTAL_VARIABLES": { 3 | "REINVENT_DEVELOPMENT_ENVIRONMENT": "1" 4 | }, 5 | "MAIN_TEST_PATH": "tests", 6 | "SMILES_SET_PATH": "", 7 | "PRIOR_PATH": "", 8 | "LIBINVENT_PRIOR_PATH": "", 9 | "SMILES_SET_LINK_INVENT_PATH":"", 10 | "LINK_INVENT_PRIOR_PATH": "", 11 | "MOLFORMER_PRIOR_PATH": "" 12 | } 13 | -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/fixtures/utils.py: -------------------------------------------------------------------------------- 1 | import warnings 2 | import os 3 | 4 | 5 | def ignore_warnings(test_func): 6 | def do_test(self, *args, **kwargs): 7 | with warnings.catch_warnings(): 8 | warnings.simplefilter("ignore") 9 | test_func(self, *args, **kwargs) 10 | 11 | return do_test 12 | 13 | def count_empty_files(folder: str) -> int: 14 | empty_files_count = 0 15 | for item in os.listdir(folder): 16 | itempath = os.path.join(folder, item) 17 | if os.path.isfile(itempath): 18 | if os.path.getsize(itempath) == 0: 19 | empty_files_count += 1 20 | # We already know that 'itempath' exists, so if it is not a file it must be a directory 21 | else: 22 | empty_files_count += count_empty_files(itempath) 23 | return empty_files_count 24 | -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/__init__.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.running_modes.create_model_tests import * 2 | from unittest_reinvent.running_modes.curriculum_tests import * 3 | from unittest_reinvent.running_modes.inception_tests import * 4 | from unittest_reinvent.running_modes.local_logger_tests import * 5 | from unittest_reinvent.running_modes.model_validation_tests import * 6 | from unittest_reinvent.running_modes.reinforcement_tests import * 7 | from unittest_reinvent.running_modes.sample_model_tests import * 8 | from unittest_reinvent.running_modes.scoring_runner_tests import * 9 | from unittest_reinvent.running_modes.transfer_learning_tests import * 10 | from unittest_reinvent.running_modes.lib_invent_tests import * 11 | 12 | from unittest_reinvent.running_modes.create_model_tests import test_molformer_create_model 13 | from unittest_reinvent.running_modes.transfer_learning_tests import test_molformer_transfer_learning 14 | -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/create_model_tests/__init__.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.running_modes.create_model_tests.test_create_model import TestCreateModel 2 | from unittest_reinvent.running_modes.create_model_tests.test_link_invent_create_model import TestLinkInventCreateModel 3 | from unittest_reinvent.running_modes.create_model_tests.test_molformer_create_model import TestMolformerCreateModel 4 | -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/curriculum_tests/__init__.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.running_modes.curriculum_tests.test_manual_curriculum_learning import \ 2 | TestManualCurriculumLearning 3 | 4 | from unittest_reinvent.running_modes.curriculum_tests.test_automated_curriculum_learning import \ 5 | TestAutomatedCurriculumLearning 6 | from unittest_reinvent.running_modes.curriculum_tests.test_no_curriculum_molformer import TestNoCurriculumMolformer 7 | from unittest_reinvent.running_modes.curriculum_tests.test_molformer_curriculum_learning import \ 8 | TestMolformerCurriculumLearning 9 | -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/inception_tests/__init__.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.running_modes.inception_tests.test_add import TestInceptionModelAdd 2 | from unittest_reinvent.running_modes.inception_tests.test_add_jaccard_distance import TestInceptionAddJaccardDistance 3 | from unittest_reinvent.running_modes.inception_tests.test_eval_add_tanimoto import TestInceptionEvalAddTanimoto 4 | from unittest_reinvent.running_modes.inception_tests.test_empty_add import TestInceptionEmptyAddSmiles 5 | from unittest_reinvent.running_modes.inception_tests.test_empty_eval_add_tanimoto import \ 6 | TestInceptionEmptyEvalAddTanimoto 7 | -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/inception_tests/test_add_jaccard_distance.py: -------------------------------------------------------------------------------- 1 | import pytest 2 | 3 | from unittest_reinvent.running_modes.inception_tests.test_add_base import TestInceptionAddBase 4 | 5 | 6 | @pytest.mark.integration 7 | class TestInceptionAddJaccardDistance(TestInceptionAddBase): 8 | 9 | def test_eval_add_1(self): 10 | self.assertEqual(len(self.inception_model.memory), 3) 11 | -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/lib_invent_tests/__init__.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.running_modes.lib_invent_tests.logger_tests import * 2 | from unittest_reinvent.running_modes.lib_invent_tests.reinforcement_learning_tests import * 3 | from unittest_reinvent.running_modes.lib_invent_tests.scoring_strategy_tests import * 4 | from unittest_reinvent.running_modes.lib_invent_tests.learning_strategy_tests import * 5 | -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/lib_invent_tests/learning_strategy_tests/__init__.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.running_modes.lib_invent_tests.learning_strategy_tests.test_learning_strategy_sdap_strategy \ 2 | import TestLearningStrategySdapStrategy 3 | from unittest_reinvent.running_modes.lib_invent_tests.learning_strategy_tests.test_learning_strategy_dap_strategy \ 4 | import TestLearningStrategyDapStrategy 5 | from unittest_reinvent.running_modes.lib_invent_tests.learning_strategy_tests.test_learning_strategy_mauli_strategy \ 6 | import TestLearningStrategyMauliStrategy 7 | from unittest_reinvent.running_modes.lib_invent_tests.learning_strategy_tests.test_learning_strategy_mascof_strategy \ 8 | import TestLearningStrategyMascofStrategy 9 | -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/lib_invent_tests/learning_strategy_tests/test_learning_strategy_dap_strategy.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import pytest 3 | 4 | from running_modes.reinforcement_learning.learning_strategy import LearningStrategyEnum 5 | from unittest_reinvent.running_modes.lib_invent_tests.learning_strategy_tests.base_learning_strategy import \ 6 | BaseTestLearningStrategy 7 | 8 | 9 | @pytest.mark.integration 10 | class TestLearningStrategyDapStrategy(BaseTestLearningStrategy): 11 | 12 | def setUp(self): 13 | super().arrange(LearningStrategyEnum().DAP) 14 | 15 | def test_dap_strategy(self): 16 | actor_nlls, critic_nlls, augmented_nlls = \ 17 | self.runner.run(self.scaffold_batch, self.decorator_batch, self.score, self.actor_nlls) 18 | 19 | self.assertEqual(actor_nlls, torch.neg(self.actor_nlls)) 20 | self.assertEqual(critic_nlls, -0.3) 21 | self.assertEqual(augmented_nlls, 89.7) 22 | 23 | 24 | -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/lib_invent_tests/learning_strategy_tests/test_learning_strategy_mascof_strategy.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import pytest 3 | 4 | from running_modes.reinforcement_learning.learning_strategy import LearningStrategyEnum 5 | from unittest_reinvent.running_modes.lib_invent_tests.learning_strategy_tests.base_learning_strategy import \ 6 | BaseTestLearningStrategy 7 | 8 | 9 | @pytest.mark.integration 10 | class TestLearningStrategyMascofStrategy(BaseTestLearningStrategy): 11 | 12 | def setUp(self): 13 | super().arrange(LearningStrategyEnum().MASCOF) 14 | 15 | def test_mascof_strategy(self): 16 | actor_nlls, critic_nlls, augmented_nlls = \ 17 | self.runner.run(self.scaffold_batch, self.decorator_batch, self.score, self.actor_nlls) 18 | 19 | self.assertEqual(actor_nlls, torch.neg(self.actor_nlls)) 20 | self.assertEqual(critic_nlls, -0.3) 21 | self.assertEqual(augmented_nlls, 0.9) 22 | -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/lib_invent_tests/learning_strategy_tests/test_learning_strategy_mauli_strategy.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import pytest 3 | 4 | from running_modes.reinforcement_learning.learning_strategy import LearningStrategyEnum 5 | from unittest_reinvent.running_modes.lib_invent_tests.learning_strategy_tests.base_learning_strategy import \ 6 | BaseTestLearningStrategy 7 | 8 | 9 | @pytest.mark.integration 10 | class TestLearningStrategyMauliStrategy(BaseTestLearningStrategy): 11 | 12 | def setUp(self): 13 | super().arrange(LearningStrategyEnum().MAULI) 14 | 15 | def test_mauli_strategy(self): 16 | actor_nlls, critic_nlls, augmented_nlls = \ 17 | self.runner.run(self.scaffold_batch, self.decorator_batch, self.score, self.actor_nlls) 18 | 19 | self.assertEqual(actor_nlls, torch.neg(self.actor_nlls)) 20 | self.assertEqual(critic_nlls, -0.3) 21 | self.assertEqual(augmented_nlls, 89.7) 22 | -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/lib_invent_tests/learning_strategy_tests/test_learning_strategy_sdap_strategy.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import pytest 3 | 4 | from running_modes.reinforcement_learning.learning_strategy import LearningStrategyEnum 5 | from unittest_reinvent.running_modes.lib_invent_tests.learning_strategy_tests.base_learning_strategy import \ 6 | BaseTestLearningStrategy 7 | 8 | 9 | @pytest.mark.integration 10 | class TestLearningStrategySdapStrategy(BaseTestLearningStrategy): 11 | 12 | def setUp(self): 13 | super().arrange(LearningStrategyEnum().SDAP) 14 | 15 | def test_sdap_strategy(self): 16 | actor_nlls, critic_nlls, augmented_nlls = \ 17 | self.runner.run(self.scaffold_batch, self.decorator_batch, self.score, self.actor_nlls) 18 | 19 | self.assertEqual(actor_nlls, torch.neg(self.actor_nlls)) 20 | self.assertEqual(critic_nlls, -0.3) 21 | self.assertEqual(augmented_nlls, 89.7) 22 | -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/lib_invent_tests/logger_tests/__init__.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.running_modes.lib_invent_tests.logger_tests.test_reinforcement_logger import \ 2 | TestReinforcementLogger -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/lib_invent_tests/reinforcement_learning_tests/__init__.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.running_modes.lib_invent_tests.reinforcement_learning_tests.test_reinforcement_learning_model \ 2 | import TestReinforcementLearningModel 3 | from unittest_reinvent.running_modes.lib_invent_tests.reinforcement_learning_tests.test_reinforcement_learning_likelihood_evaluation \ 4 | import TestReinforcementLearningLikelihoodEvaluation 5 | -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/lib_invent_tests/scoring_strategy_tests/__init__.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.running_modes.lib_invent_tests.scoring_strategy_tests.test_standard_scoring_strategy_no_reaction_filter \ 2 | import TestStandardScoringStrategyNoReactionFilter -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/local_logger_tests/__init__.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.running_modes.local_logger_tests.test_sampling_invalid_smiles import TestSamplingInvalidSmiles 2 | from unittest_reinvent.running_modes.local_logger_tests.test_transfer_logger import TestTransferLogger 3 | 4 | -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/model_validation_tests/__init__.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.running_modes.model_validation_tests.test_model_validation import TestModelValidity -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/reinforcement_tests/test_margin_guard_adjust_guard_on_empty.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | from unittest.mock import Mock 3 | 4 | from running_modes.reinforcement_learning.margin_guard import MarginGuard 5 | 6 | 7 | class MarginGuardAdjustGuardOnEmptyTest(unittest.TestCase): 8 | def setUp(self) -> None: 9 | self.runner = Mock() 10 | self.margin_window = 10 11 | self.mg = MarginGuard(self.runner, self.margin_window) 12 | 13 | def test_empty(self): 14 | self.assertRaises(Exception, self.mg.adjust_margin, self.margin_window) 15 | -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/sample_model_tests/__init__.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.running_modes.sample_model_tests.test_sample_from_model import TestSampleFromModel 2 | -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/scoring_runner_tests/__init__.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.running_modes.scoring_runner_tests.test_scoring_runner import TestScoringRunner 2 | -------------------------------------------------------------------------------- /reinvent/reinventcli/unittest_reinvent/running_modes/transfer_learning_tests/__init__.py: -------------------------------------------------------------------------------- 1 | from unittest_reinvent.running_modes.transfer_learning_tests.test_transfer_learning import TestTransferLearning 2 | from unittest_reinvent.running_modes.transfer_learning_tests.test_link_invent_transfer_learning import \ 3 | TestLinkInventTransferLearning 4 | from unittest_reinvent.running_modes.transfer_learning_tests.test_molformer_transfer_learning import TestMolformerTransferLearning 5 | --------------------------------------------------------------------------------