gt4sd.algorithms.generation.paccmann_vae.core module

PaccMannVAE Algorithm.

PaccMannVAE is an unconditional molecular generative model.

Summary

Classes:

PaccMannVAE	Molecular VAE as in the PaccMannRL paper.
PaccMannVAEGenerator	Configuration to generate molecules with PaccMannVAE.

Reference

class PaccMannVAE(configuration, target=None)

Bases: GeneratorAlgorithm[S, None]

Molecular VAE as in the PaccMann^RL paper.

__init__(configuration, target=None)

Instantiate PaccMannVAE ready to generate molecules.

Parameters

• configuration (AlgorithmConfiguration[~S, None]) – domain and application specification defining parameters, types and validations.

• target (None) – unused since it is not a conditional generator.

Example

An example for unconditional generation of small molecules:

config = PaccMannVAEGenerator()
algorithm = PaccMannVAE(configuration=config)
items = list(algorithm.sample(10))
print(items)

get_generator(configuration, target)

Get the function to sample batches via PaccMannVAE.

Parameters

configuration (AlgorithmConfiguration[~S, None]) – helps to set up specific application of PaccMannVAE.

Return type

Callable[[], Iterable[Any]]

Returns

callable with target generating a batch of items.

__abstractmethods__ = frozenset({})

__annotations__ = {'generate': 'Untargeted', 'generator': 'Union[Untargeted, Targeted[T]]', 'max_runtime': 'int', 'max_samples': 'int', 'target': 'Optional[T]'}

__doc__ = 'Molecular VAE as in the PaccMann\\ :superscript:`RL` paper.'

__module__ = 'gt4sd.algorithms.generation.paccmann_vae.core'

__orig_bases__ = (gt4sd.algorithms.core.GeneratorAlgorithm[~S, NoneType],)

__parameters__ = (~S,)

_abc_impl = <_abc._abc_data object>

class PaccMannVAEGenerator(*args, **kwargs)

Bases: PaccMannVAEGenerator, Generic[T]

Configuration to generate molecules with PaccMannVAE.

Implementation from the paper: https://doi.org/10.1016/j.isci.2021.102269

algorithm_type: ClassVar[str] = 'generation'

General type of generative algorithm.

domain: ClassVar[str] = 'materials'

General application domain. Hints at input/output types.

algorithm_version: str = 'v0'

To differentiate between different versions of an application.

There is no imposed naming convention.

batch_size: int = 32

temperature: float = 1.4

generated_length: int = 100

get_target_description()

Get description of the target for generation.

Return type

Optional[Dict[str, str], None]

Returns

target description.

get_conditional_generator()

Instantiate the actual generator implementation.

Parameters

resources_path – local path to model files.

Return type

PaccMannVaeDefaultGenerator

Returns

instance with generate_batch method for targeted generation.

classmethod list_versions()

Get possible algorithm versions.

S3 is searched as well as the local cache is searched for matching versions.

Return type

Set[str]

Returns

viable values as algorithm_version for the environment.

__annotations__ = {'algorithm_application': 'ClassVar[str]', 'algorithm_name': 'ClassVar[str]', 'algorithm_type': typing.ClassVar[str], 'algorithm_version': <class 'str'>, 'batch_size': <class 'int'>, 'domain': typing.ClassVar[str], 'generated_length': <class 'int'>, 'temperature': <class 'float'>}

__dataclass_fields__ = {'algorithm_application': Field(name='algorithm_application',type=typing.ClassVar[str],default='PaccMannVAEGenerator',default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=<dataclasses._MISSING_TYPE object>,_field_type=_FIELD_CLASSVAR), 'algorithm_name': Field(name='algorithm_name',type=typing.ClassVar[str],default='PaccMannVAE',default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=<dataclasses._MISSING_TYPE object>,_field_type=_FIELD_CLASSVAR), 'algorithm_type': Field(name='algorithm_type',type=typing.ClassVar[str],default='generation',default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=<dataclasses._MISSING_TYPE object>,_field_type=_FIELD_CLASSVAR), 'algorithm_version': Field(name='algorithm_version',type=<class 'str'>,default='v0',default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'batch_size': Field(name='batch_size',type=<class 'int'>,default=32,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({'description': 'Batch size used for the generative model sampling.'}),kw_only=False,_field_type=_FIELD), 'domain': Field(name='domain',type=typing.ClassVar[str],default='materials',default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=<dataclasses._MISSING_TYPE object>,_field_type=_FIELD_CLASSVAR), 'generated_length': Field(name='generated_length',type=<class 'int'>,default=100,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({'description': 'Maximum length in tokens of the generated molcules (relates to the SMILES length).'}),kw_only=False,_field_type=_FIELD), 'temperature': Field(name='temperature',type=<class 'float'>,default=1.4,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({'description': 'Temperature parameter for the softmax sampling in decoding.'}),kw_only=False,_field_type=_FIELD)}

__dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False)

__doc__ = '\n    Configuration to generate molecules with PaccMannVAE.\n\n    Implementation from the paper: https://doi.org/10.1016/j.isci.2021.102269\n    '

__eq__(other)

Return self==value.

__hash__ = None

__init__(*args, **kwargs)

__match_args__ = ('algorithm_version', 'batch_size', 'temperature', 'generated_length')

__module__ = 'gt4sd.algorithms.generation.paccmann_vae.core'

__orig_bases__ = (<class 'types.PaccMannVAEGenerator'>, typing.Generic[~T])

__parameters__ = (~T,)

__pydantic_complete__ = True

__pydantic_config__ = {}

__pydantic_core_schema__ = {'cls': <class 'gt4sd.algorithms.generation.paccmann_vae.core.PaccMannVAEGenerator'>, 'config': {'title': 'PaccMannVAEGenerator'}, 'fields': ['algorithm_version', 'batch_size', 'temperature', 'generated_length'], 'frozen': False, 'metadata': {'pydantic_js_annotation_functions': [], 'pydantic_js_functions': [functools.partial(<function modify_model_json_schema>, cls=<class 'gt4sd.algorithms.generation.paccmann_vae.core.PaccMannVAEGenerator'>, title=None)]}, 'post_init': False, 'ref': 'types.PaccMannVAEGenerator:94662829823344', 'schema': {'collect_init_only': False, 'computed_fields': [], 'dataclass_name': 'PaccMannVAEGenerator', 'fields': [{'type': 'dataclass-field', 'name': 'algorithm_version', 'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default': 'v0'}, 'kw_only': False, 'init': True, 'metadata': {'pydantic_js_functions': [], 'pydantic_js_annotation_functions': [<function get_json_schema_update_func.<locals>.json_schema_update_func>]}}, {'type': 'dataclass-field', 'name': 'batch_size', 'schema': {'type': 'default', 'schema': {'type': 'int'}, 'default': 32}, 'kw_only': False, 'init': True, 'metadata': {'pydantic_js_functions': [], 'pydantic_js_annotation_functions': [<function get_json_schema_update_func.<locals>.json_schema_update_func>]}}, {'type': 'dataclass-field', 'name': 'temperature', 'schema': {'type': 'default', 'schema': {'type': 'float'}, 'default': 1.4}, 'kw_only': False, 'init': True, 'metadata': {'pydantic_js_functions': [], 'pydantic_js_annotation_functions': [<function get_json_schema_update_func.<locals>.json_schema_update_func>]}}, {'type': 'dataclass-field', 'name': 'generated_length', 'schema': {'type': 'default', 'schema': {'type': 'int'}, 'default': 100}, 'kw_only': False, 'init': True, 'metadata': {'pydantic_js_functions': [], 'pydantic_js_annotation_functions': [<function get_json_schema_update_func.<locals>.json_schema_update_func>]}}], 'type': 'dataclass-args'}, 'slots': True, 'type': 'dataclass'}

__pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={}, root_validators={}, field_serializers={}, model_serializers={}, model_validators={}, computed_fields={})

__pydantic_fields__ = {'algorithm_version': FieldInfo(annotation=str, required=False, default='v0', init=True, init_var=False, kw_only=False), 'batch_size': FieldInfo(annotation=int, required=False, default=32, description='Batch size used for the generative model sampling.', init=True, init_var=False, kw_only=False), 'generated_length': FieldInfo(annotation=int, required=False, default=100, description='Maximum length in tokens of the generated molcules (relates to the SMILES length).', init=True, init_var=False, kw_only=False), 'temperature': FieldInfo(annotation=float, required=False, default=1.4, description='Temperature parameter for the softmax sampling in decoding.', init=True, init_var=False, kw_only=False)}

__pydantic_serializer__ = SchemaSerializer(serializer=Dataclass(     DataclassSerializer {         class: Py(             0x0000561868585570,         ),         serializer: Fields(             GeneralFieldsSerializer {                 fields: {                     "algorithm_version": SerField {                         key_py: Py(                             0x00007f1dc3855840,                         ),                         alias: None,                         alias_py: None,                         serializer: Some(                             WithDefault(                                 WithDefaultSerializer {                                     default: Default(                                         Py(                                             0x00007f1ea52cf3f0,                                         ),                                     ),                                     serializer: Str(                                         StrSerializer,                                     ),                                 },                             ),                         ),                         required: true,                     },                     "batch_size": SerField {                         key_py: Py(                             0x00007f1dc38296b0,                         ),                         alias: None,                         alias_py: None,                         serializer: Some(                             WithDefault(                                 WithDefaultSerializer {                                     default: Default(                                         Py(                                             0x00007f1ea94684d0,                                         ),                                     ),                                     serializer: Int(                                         IntSerializer,                                     ),                                 },                             ),                         ),                         required: true,                     },                     "temperature": SerField {                         key_py: Py(                             0x00007f1dc38291f0,                         ),                         alias: None,                         alias_py: None,                         serializer: Some(                             WithDefault(                                 WithDefaultSerializer {                                     default: Default(                                         Py(                                             0x00007f1dc3929890,                                         ),                                     ),                                     serializer: Float(                                         FloatSerializer {                                             inf_nan_mode: Null,                                         },                                     ),                                 },                             ),                         ),                         required: true,                     },                     "generated_length": SerField {                         key_py: Py(                             0x00007f1dc3855890,                         ),                         alias: None,                         alias_py: None,                         serializer: Some(                             WithDefault(                                 WithDefaultSerializer {                                     default: Default(                                         Py(                                             0x00007f1ea9468d50,                                         ),                                     ),                                     serializer: Int(                                         IntSerializer,                                     ),                                 },                             ),                         ),                         required: true,                     },                 },                 computed_fields: Some(                     ComputedFields(                         [],                     ),                 ),                 mode: SimpleDict,                 extra_serializer: None,                 filter: SchemaFilter {                     include: None,                     exclude: None,                 },                 required_fields: 4,             },         ),         fields: [             Py(                 0x00007f1ea52ed250,             ),             Py(                 0x00007f1ea52ccc70,             ),             Py(                 0x00007f1e33d8d4b0,             ),             Py(                 0x00007f1dca9b95c0,             ),         ],         name: "PaccMannVAEGenerator",     }, ), definitions=[])

__pydantic_validator__ = SchemaValidator(title="PaccMannVAEGenerator", validator=Dataclass(     DataclassValidator {         strict: false,         validator: DataclassArgs(             DataclassArgsValidator {                 fields: [                     Field {                         kw_only: false,                         name: "algorithm_version",                         py_name: Py(                             0x00007f1ea52ed250,                         ),                         init: true,                         init_only: false,                         lookup_key: Simple {                             key: "algorithm_version",                             py_key: Py(                                 0x00007f1dc3855750,                             ),                             path: LookupPath(                                 [                                     S(                                         "algorithm_version",                                         Py(                                             0x00007f1dc38557a0,                                         ),                                     ),                                 ],                             ),                         },                         validator: WithDefault(                             WithDefaultValidator {                                 default: Default(                                     Py(                                         0x00007f1ea52cf3f0,                                     ),                                 ),                                 on_error: Raise,                                 validator: Str(                                     StrValidator {                                         strict: false,                                         coerce_numbers_to_str: false,                                     },                                 ),                                 validate_default: false,                                 copy_default: false,                                 name: "default[str]",                                 undefined: Py(                                     0x00007f1ea71db950,                                 ),                             },                         ),                         frozen: false,                     },                     Field {                         kw_only: false,                         name: "batch_size",                         py_name: Py(                             0x00007f1ea52ccc70,                         ),                         init: true,                         init_only: false,                         lookup_key: Simple {                             key: "batch_size",                             py_key: Py(                                 0x00007f1dc3945470,                             ),                             path: LookupPath(                                 [                                     S(                                         "batch_size",                                         Py(                                             0x00007f1dc3944070,                                         ),                                     ),                                 ],                             ),                         },                         validator: WithDefault(                             WithDefaultValidator {                                 default: Default(                                     Py(                                         0x00007f1ea94684d0,                                     ),                                 ),                                 on_error: Raise,                                 validator: Int(                                     IntValidator {                                         strict: false,                                     },                                 ),                                 validate_default: false,                                 copy_default: false,                                 name: "default[int]",                                 undefined: Py(                                     0x00007f1ea71db950,                                 ),                             },                         ),                         frozen: false,                     },                     Field {                         kw_only: false,                         name: "temperature",                         py_name: Py(                             0x00007f1e33d8d4b0,                         ),                         init: true,                         init_only: false,                         lookup_key: Simple {                             key: "temperature",                             py_key: Py(                                 0x00007f1dc3945bf0,                             ),                             path: LookupPath(                                 [                                     S(                                         "temperature",                                         Py(                                             0x00007f1dc3818b30,                                         ),                                     ),                                 ],                             ),                         },                         validator: WithDefault(                             WithDefaultValidator {                                 default: Default(                                     Py(                                         0x00007f1dc3929890,                                     ),                                 ),                                 on_error: Raise,                                 validator: Float(                                     FloatValidator {                                         strict: false,                                         allow_inf_nan: true,                                     },                                 ),                                 validate_default: false,                                 copy_default: false,                                 name: "default[float]",                                 undefined: Py(                                     0x00007f1ea71db950,                                 ),                             },                         ),                         frozen: false,                     },                     Field {                         kw_only: false,                         name: "generated_length",                         py_name: Py(                             0x00007f1dca9b95c0,                         ),                         init: true,                         init_only: false,                         lookup_key: Simple {                             key: "generated_length",                             py_key: Py(                                 0x00007f1dc3855700,                             ),                             path: LookupPath(                                 [                                     S(                                         "generated_length",                                         Py(                                             0x00007f1dc38557f0,                                         ),                                     ),                                 ],                             ),                         },                         validator: WithDefault(                             WithDefaultValidator {                                 default: Default(                                     Py(                                         0x00007f1ea9468d50,                                     ),                                 ),                                 on_error: Raise,                                 validator: Int(                                     IntValidator {                                         strict: false,                                     },                                 ),                                 validate_default: false,                                 copy_default: false,                                 name: "default[int]",                                 undefined: Py(                                     0x00007f1ea71db950,                                 ),                             },                         ),                         frozen: false,                     },                 ],                 positional_count: 4,                 init_only_count: None,                 dataclass_name: "PaccMannVAEGenerator",                 validator_name: "dataclass-args[PaccMannVAEGenerator]",                 extra_behavior: Ignore,                 extras_validator: None,                 loc_by_alias: true,             },         ),         class: Py(             0x0000561868585570,         ),         fields: [             Py(                 0x00007f1ea52ed250,             ),             Py(                 0x00007f1ea52ccc70,             ),             Py(                 0x00007f1e33d8d4b0,             ),             Py(                 0x00007f1dca9b95c0,             ),         ],         post_init: None,         revalidate: Never,         name: "PaccMannVAEGenerator",         frozen: false,         slots: true,     }, ), definitions=[], cache_strings=True)

__repr__()

Return repr(self).

__signature__ = <Signature (algorithm_version: str = 'v0', batch_size: int = 32, temperature: float = 1.4, generated_length: int = 100) -> None>

__wrapped__

alias of PaccMannVAEGenerator