class DummyDescriptor(object): dummy_map = properties.Mapping(properties.Float(), properties.String) dummy_list = properties.List(properties.Float, properties.String) dummy_set = properties.Set(type(properties.Float())) link_or_else = properties.LinkOrElse() map_collection_key = properties.Mapping( properties.Optional(properties.String), properties.Integer) specified_mixed_list = properties.SpecifiedMixedList( [properties.Integer(default=100)])
class IngredientsToFormulationPredictor( Resource['IngredientsToFormulationPredictor'], Predictor, AIResourceMetadata): """[ALPHA] A predictor interface that constructs a formulation from ingredient quantities. Parameters ---------- name: str name of the configuration description: str description of the predictor output: FormulationDescriptor descriptor that represents the output formulation id_to_quantity: Mapping[str, RealDescriptor] Map from ingredient identifier to the descriptor that represents its quantity, e.g., ``{'water': RealDescriptor('water quantity', 0, 1, "")}`` labels: Mapping[str, Set[str]] Map from each label to all ingredients assigned that label, when present in a mixture, e.g., ``{'solvent': {'water'}}`` """ _resource_type = ResourceTypeEnum.MODULE output = _properties.Object(FormulationDescriptor, 'config.output') id_to_quantity = _properties.Mapping(_properties.String, _properties.Object(RealDescriptor), 'config.id_to_quantity') labels = _properties.Mapping(_properties.String, _properties.Set(_properties.String), 'config.labels') typ = _properties.String('config.type', default='IngredientsToSimpleMixture', deserializable=False) module_type = _properties.String('module_type', default='PREDICTOR') def __init__(self, name: str, description: str, output: FormulationDescriptor, id_to_quantity: Mapping[str, RealDescriptor], labels: Mapping[str, Set[str]], archived: bool = False): self.name: str = name self.description: str = description self.output: FormulationDescriptor = output self.id_to_quantity: Mapping[str, RealDescriptor] = id_to_quantity self.labels: Mapping[str, Set[str]] = labels self.archived: bool = archived def _post_dump(self, data: dict) -> dict: data['display_name'] = data['config']['name'] return data def __str__(self): return '<IngredientsToFormulationPredictor {!r}>'.format(self.name)
class CSVDataSource(Serializable['CSVDataSource'], DataSource): """A data source based on a CSV file stored on the data platform. Parameters ---------- file_link: FileLink link to the CSV file to read the data from column_definitions: Mapping[str, Descriptor] Map the column headers to the descriptors that will be used to interpret the cell contents identifiers: Optional[List[str]] List of one or more column headers whose values uniquely identify a row. These may overlap with ``column_definitions`` if a column should be used as data and as an identifier, but this is not necessary. Identifiers must be unique within a dataset. No two rows can contain the same value. """ typ = properties.String('type', default='csv_data_source', deserializable=False) file_link = properties.Object(FileLink, "file_link") column_definitions = properties.Mapping( properties.String, properties.Object(Descriptor), "column_definitions") identifiers = properties.Optional(properties.List(properties.String), "identifiers") def _attrs(self) -> List[str]: return ["file_link", "column_definitions", "identifiers", "typ"] def __init__(self, file_link: FileLink, column_definitions: Mapping[str, Descriptor], identifiers: Optional[List[str]] = None): self.file_link = file_link self.column_definitions = column_definitions self.identifiers = identifiers
class FeatureImportanceReport(Serializable["FeatureImportanceReport"]): """[ALPHA] Feature importances for a specific model response. FeatureImportanceReport objects are constructed from saved models and should not be user-instantiated. Parameters ---------- output_key: str key for the output importances: dict[str, float] feature importances """ output_key = properties.String('response_key') importances = properties.Mapping(keys_type=properties.String, values_type=properties.Float, serialization_path='importances') def __init__(self, output_key: str, importances: Dict[str, float]): self.output_key = output_key self.importances = importances def __str__(self): return "<FeatureImportanceReport {!r}>".format(self.output_key)
class JobStatusResponse(Resource['JobStatusResponse']): """[ALPHA] a response to a job status check. The JobStatusResponse summarizes the status for the entire job. Parameters ---------- job_type: str the type of job for this status report status: str the actual status of the job. One of "Running", "Success", or "Failure". tasks: List[TaskNode] all of the constituent task required to complete this job output: Optional[Map[String,String]] job output properties and results """ job_type = properties.String("job_type") status = properties.String("status") tasks = properties.List(Object(TaskNode), "tasks") output = properties.Optional(properties.Mapping(String, String), 'output') def __init__( self, job_type: str, status: str, tasks: List[TaskNode], output: Optional[Dict[str, str]] ): self.job_type = job_type self.status = status self.tasks = tasks self.output = output
class ResponseMetrics(Serializable["ResponseMetrics"]): """Set of metrics computed by a Predictor Evaluator for a single response. Results computed for a metric can be accessed by the metric's ``__repr__`` or by the metric itself. """ metrics = properties.Mapping(properties.String, properties.Object(MetricValue), "metrics") """:Dict[str, MetricValue]: Metrics computed for a single response, keyed by the metric's ``__repr__``.""" def __init__(self): pass # pragma: no cover def __iter__(self): return iter(self.metrics) def __getitem__(self, item): if isinstance(item, str): return self.metrics[item] elif isinstance(item, PredictorEvaluationMetric): return self.metrics[repr(item)] else: raise TypeError("Cannot index ResponseMetrics with a {}".format( type(item)))
def test_mapping_property(key_type, value_type, key_value, value_value, key_serialized, value_serialized): prop = properties.Mapping(key_type, value_type) value = {key_value: value_value} serialized = {key_serialized: value_serialized} assert prop.deserialize(serialized) == value assert prop.serialize(value) == serialized
class ExpressionPredictor(Resource['ExpressionPredictor'], Predictor, AIResourceMetadata): """A predictor that computes an output from an expression and set of bounded inputs. For a discussion of expression syntax and a list of allowed symbols, please see the :ref:`documentation<Expression Predictor>`. .. seealso:: If you are using the deprecated predictor please see :class:`~citrine.informatics.predictors.DeprecatedExpressionPredictor` for an example that shows how to migrate to the new format. Parameters ---------- name: str name of the configuration description: str the description of the predictor expression: str expression that computes an output from aliased inputs output: RealDescriptor descriptor that represents the output of the expression aliases: Mapping[str, RealDescriptor] a mapping from each unknown argument to its descriptor. All unknown arguments must have an associated descriptor. """ expression = _properties.String('config.expression') output = _properties.Object(RealDescriptor, 'config.output') aliases = _properties.Mapping(_properties.String, _properties.Object(RealDescriptor), 'config.aliases') typ = _properties.String('config.type', default='AnalyticExpression', deserializable=False) module_type = _properties.String('module_type', default='PREDICTOR') def __init__(self, name: str, description: str, expression: str, output: RealDescriptor, aliases: Mapping[str, RealDescriptor], archived: bool = False): self.name: str = name self.description: str = description self.expression: str = expression self.output: RealDescriptor = output self.aliases: Mapping[str, RealDescriptor] = aliases self.archived: bool = archived def _post_dump(self, data: dict) -> dict: data['display_name'] = data['config']['name'] return data def __str__(self): return '<ExpressionPredictor {!r}>'.format(self.name)
class DesignMaterial(Serializable["DesignMaterial"]): """Description of the material that was designed, as a set of DesignVariables.""" values = properties.Mapping(properties.String, properties.Object(DesignVariable), 'vars') """:Dict[str, DesignVariable]: mapping from descriptor keys to the value for this material""" def __init__(self): pass # pragma: no cover
def test_mapping_property_list_of_pairs_multiple(): prop = properties.Mapping(properties.String, properties.Integer, ser_as_list_of_pairs=True) value = {'foo': 1, 'bar': 2} serialized = [('foo', 1), ('bar', 2)] assert prop.deserialize(serialized) == value unittest.TestCase().assertCountEqual(prop.serialize(value), serialized)
class EnumeratedDesignSpace(Resource['EnumeratedDesignSpace'], DesignSpace): """Design space composed of an explicit enumeration of candidate materials to score. Note that every candidate must have exactly the descriptors in the list populated (no more, no less) to be included. Parameters ---------- name:str the name of the design space description:str the description of the design space descriptors: list[Descriptor] the list of descriptors included in the candidates of the design space data: list[dict] list of dicts of the shape `{<descriptor_key>: <descriptor_value>}` where each dict corresponds to a candidate in the design space """ _response_key = None uid = properties.Optional(properties.UUID, 'id', serializable=False) name = properties.String('config.name') description = properties.Optional(properties.String(), 'config.description') descriptors = properties.List(properties.Object(Descriptor), 'config.descriptors') data = properties.List( properties.Mapping(properties.String, properties.Raw), 'config.data') typ = properties.String('config.type', default='EnumeratedDesignSpace', deserializable=False) status = properties.String('status', serializable=False) status_info = properties.Optional(properties.List(properties.String()), 'status_info', serializable=False) # NOTE: These could go here or in _post_dump - it's unclear which is better right now module_type = properties.String('module_type', default='DESIGN_SPACE') schema_id = properties.UUID( 'schema_id', default=UUID('f3907a58-aa46-462c-8837-a5aa9605e79e')) def __init__(self, name: str, description: str, descriptors: List[Descriptor], data: List[Mapping[str, Any]], session: Session = Session()): self.name: str = name self.description: str = description self.descriptors: List[Descriptor] = descriptors self.data: List[Mapping[str, Any]] = data self.session: Session = session def _post_dump(self, data: dict) -> dict: data['display_name'] = data['config']['name'] return data def __str__(self): return '<EnumeratedDesignSpace {!r}>'.format(self.name)
def test_mapping_property_list_of_pairs(key_type, value_type, key_value, value_value, key_serialized, value_serialized): prop = properties.Mapping(key_type, value_type, ser_as_list_of_pairs=True) value = {key_value: value_value} serialized = [ (key_serialized, value_serialized), ] assert prop.deserialize(serialized) == value unittest.TestCase().assertCountEqual(prop.serialize(value), serialized)
class Mixture(Serializable["Mixture"], DesignVariable): """Most likely quantity values for all of the components in a mixture. This is a complete list of components with non-zero quantities; there is no truncation (but there may be rounding). """ quantities = properties.Mapping(properties.String, properties.Float, 'q') """:Dict[str, float]: mapping from ingredient identifiers to their quantities""" def __init__(self): pass # pragma: no cover
class TopCategories(Serializable["CategoriesAndProbabilities"], DesignVariable): """The category names and probabilities for the most probable categories. This list is truncated: these are the most probable categories but other categories may have non-zero probabilities. """ probabilities = properties.Mapping(properties.String, properties.Float, 'cp') """:Dict[str, float]: mapping from category names to their probabilities""" def __init__(self): pass # pragma: no cover
class PredictedVsActualCategoricalPoint( Serializable["PredictedVsActualCategoricalPoint"]): """Predicted vs. actual data for a single categorical data point.""" uuid = properties.UUID("uuid") """:UUID: Unique Citrine id given to the candidate""" identifiers = properties.Set(properties.String, "identifiers") """:Set[str]: Set of globally unique identifiers given to the candidate""" trial = properties.Integer("trial") """:int: 1-based index of the trial this candidate belonged to""" fold = properties.Integer("fold") """:int: 1-based index of the fold this candidate belonged to""" predicted = properties.Mapping(properties.String, properties.Float, "predicted") """:Dict[str, float]: Predicted class probabilities defined as a map from each class name to its relative frequency""" actual = properties.Mapping(properties.String, properties.Float, "actual") """:Dict[str, float]: Actual class probabilities defined as a map from each class name to its relative frequency""" def __init__(self): pass # pragma: no cover
class GridProcessor(Resource['GridProcessor'], Processor, AIResourceMetadata): """Generates samples from the Cartesian product of finite dimensions, then scans over them. For each continuous dimensions, a uniform grid is created between the lower and upper bounds of the descriptor. The number of points along each continuous dimension is specified. by ``grid_sizes``. No such discretization is necessary for enumerated dimensions, because they are finite. Be careful when using a grid processor, as the number of points grows exponentially with the number of dimensions. For high-dimensional design spaces, a continuous processor is often preferable. Parameters ---------- name: str name of the processor description: str description of the processor grid_sizes: dict[str, int] the number of points to select along each continuous dimension, by dimension name """ _resource_type = ResourceTypeEnum.MODULE grid_sizes = properties.Mapping(properties.String, properties.Integer, 'config.grid_dimensions') typ = properties.String('config.type', default='Grid', deserializable=False) module_type = properties.String('module_type', default='PROCESSOR') def _attrs(self) -> List[str]: return ["name", "description", "grid_sizes", "typ"] def __init__(self, name: str, description: str, grid_sizes: Mapping[str, int], session: Optional[Session] = None): self.name: str = name self.description: str = description self.grid_sizes: Mapping[str, int] = grid_sizes self.session: Optional[Session] = session def _post_dump(self, data: dict) -> dict: data['display_name'] = data['config']['name'] return data def __str__(self): return '<GridProcessor {!r}>'.format(self.name)
class GridProcessor(Serializable['GridProcessor'], Processor): """Generates a finite set of materials from the domain defined by the design space, then scans over the set of materials. To create a finite set of materials from continuous dimensions, a uniform grid is created between the bounds of the descriptor. The number of points is specified by `grid_sizes`. Parameters ---------- name: str name of the processor description: str description of the processor grid_sizes: dict[str, int] the number of points to select along each dimension of the grid, by dimension name """ uid = properties.Optional(properties.UUID, 'id', serializable=False) name = properties.String('config.name') description = properties.Optional(properties.String(), 'config.description') typ = properties.String('config.type', default='Grid', deserializable=False) grid_sizes = properties.Mapping(properties.String, properties.Integer, 'config.grid_dimensions') status = properties.String('status', serializable=False) status_info = properties.Optional(properties.List(properties.String()), 'status_info', serializable=False) # NOTE: These could go here or in _post_dump - it's unclear which is better right now module_type = properties.String('module_type', default='PROCESSOR') schema_id = properties.UUID( 'schema_id', default=UUID('272791a5-5468-4344-ac9f-2811d9266a4d')) def __init__(self, name: str, description: str, grid_sizes: Mapping[str, int], session: Optional[Session] = None): self.name: str = name self.description: str = description self.grid_sizes: Mapping[str, int] = grid_sizes self.session: Optional[Session] = session def _post_dump(self, data: dict) -> dict: data['display_name'] = data['config']['name'] return data def __str__(self): return '<GridProcessor {!r}>'.format(self.name)
class EnumeratedDesignSpace(Resource['EnumeratedDesignSpace'], DesignSpace, AIResourceMetadata): """An explicit enumeration of candidate materials to score. Enumerated design spaces are intended to capture small spaces with fewer than 1000 values. For larger spaces, use the DataSourceDesignSpace. Parameters ---------- name:str the name of the design space description:str the description of the design space descriptors: list[Descriptor] the list of descriptors included in the candidates of the design space data: list[dict] list of dicts of the shape `{<descriptor_key>: <descriptor_value>}` where each dict corresponds to a candidate in the design space """ _resource_type = ResourceTypeEnum.MODULE descriptors = properties.List(properties.Object(Descriptor), 'config.descriptors') data = properties.List(properties.Mapping(properties.String, properties.Raw), 'config.data') typ = properties.String('config.type', default='EnumeratedDesignSpace', deserializable=False) module_type = properties.String('module_type', default='DESIGN_SPACE') def __init__(self, name: str, description: str, descriptors: List[Descriptor], data: List[Mapping[str, Any]], session: Session = Session()): self.name: str = name self.description: str = description self.descriptors: List[Descriptor] = descriptors self.data: List[Mapping[str, Any]] = data self.session: Session = session def _post_dump(self, data: dict) -> dict: data['display_name'] = data['config']['name'] return data def __str__(self): return '<EnumeratedDesignSpace {!r}>'.format(self.name)
class FeatureImportanceReport(Serializable["FeatureImportanceReport"]): """[ALPHA] Feature importances for a specific model response. FeatureImportanceReport objects are constructed from saved models and should not be user-instantiated. """ output_key = properties.String('response_key') """:str: output descriptor key for which these feature importances are applicable""" importances = properties.Mapping(keys_type=properties.String, values_type=properties.Float, serialization_path='importances') """:dict[str, float]: map from feature name to its importance""" def __init__(self, output_key: str, importances: Dict[str, float]): self.output_key = output_key self.importances = importances def __str__(self): return "<FeatureImportanceReport {!r}>".format(self.output_key)
class CrossValidationResult(Serializable["CrossValidationResult"], PredictorEvaluationResult): """Result of performing a cross-validation evaluation on a predictor. Results for a cross-validated response can be accessed via ``cvResult['response_name']``, where ``cvResult`` is a :class:`citrine.informatics.predictor_evaluation_result.CrossValidationResult` and ``'response_name'`` is a response analyzed by a :class:`citrine.informatics.predictor_evaluator.PredictorEvaluator`. """ _evaluator = properties.Object(PredictorEvaluator, "evaluator") _response_results = properties.Mapping(properties.String, properties.Object(ResponseMetrics), "response_results") typ = properties.String('type', default='CrossValidationResult', deserializable=False) def __getitem__(self, item): return self._response_results[item] def __iter__(self): return iter(self.responses) @property def evaluator(self) -> PredictorEvaluator: """:PredictorEvaluator: Evaluator that produced this result.""" return self._evaluator @property def responses(self) -> Set[str]: """Responses for which results are present.""" return set(self._response_results.keys()) @property def metrics(self) -> Set[PredictorEvaluationMetric]: """:Set[PredictorEvaluationMetric]: Metrics for which results are present.""" return self._evaluator.metrics
class DeprecatedExpressionPredictor(Resource['DeprecatedExpressionPredictor'], Predictor, AIResourceMetadata): """[DEPRECATED] A predictor that computes an output from an analytic expression. This predictor is deprecated. Please use the :class:`~citrine.informatics.predictors.ExpressionPredictor` instead. To migrate to the new predictor: 1. add an alias for all unknown expression arguments and 2. replace descriptor keys in ``aliases`` with the associated descriptor These changes allow the expression to respect descriptor bounds when computing the output and avoid potential descriptor mismatches if a descriptor with an identical key and different bounds is present in the graph. The following example shows how to migrate a deprecated expression predictor to the new format. In the deprecated format, an expression that computes shear modulus from Young's modulus and Poisson's ratio is given by: .. code-block:: python from citrine.informatics.predictors import DeprecatedExpressionPredictor shear_modulus = RealDescriptor( 'Property~Shear modulus', lower_bound=0, upper_bound=100, units='GPa' ) shear_modulus_predictor = DeprecatedExpressionPredictor( name = 'Shear modulus predictor', description = "Computes shear modulus from Young's modulus and Poisson's ratio.", expression = 'Y / (2 * (1 + v))', output = shear_modulus, aliases = { 'Y': "Young's modulus", 'v': "Poisson's ratio" } ) To create a predictor using the format, we need to create descriptors for the expression inputs: Young's modulus and Poisson's ratio. We also need to replace references to the descriptor keys in ``aliases`` with the new descriptors: .. code-block:: python from citrine.informatics.predictors import ExpressionPredictor # create a descriptor for each input in addition to the output youngs_modulus = RealDescriptor('Property~Young\'s modulus', lower_bound=0, upper_bound=100, units='GPa') poissons_ratio = RealDescriptor('Property~Poisson\'s ratio', lower_bound=-1, upper_bound=0.5, units='') shear_modulus = RealDescriptor('Property~Shear modulus', lower_bound=0, upper_bound=100, units='GPa') shear_modulus_predictor = ExpressionPredictor( name = 'Shear modulus predictor', description = "Computes shear modulus from Young's modulus and Poisson's ratio.", expression = 'Y / (2 * (1 + v))', output = shear_modulus, # note, arguments map to descriptors not descriptor keys aliases = { 'Y': youngs_modulus, 'v': poissons_ratio } ) .. seealso:: :class:`~citrine.informatics.predictors.ExpressionPredictor` Parameters ---------- name: str name of the configuration description: str the description of the predictor expression: str expression that computes an output from a set of inputs output: RealDescriptor descriptor that represents the output of the expression aliases: Optional[Mapping[str, str]] a mapping from each each argument as it appears in the ``expression`` to its descriptor key. If an unknown argument is not aliased, the argument and descriptor key are assumed to be identical. """ _resource_type = ResourceTypeEnum.MODULE expression = _properties.String('config.expression') output = _properties.Object(RealDescriptor, 'config.output') aliases = _properties.Optional( _properties.Mapping(_properties.String, _properties.String), 'config.aliases') typ = _properties.String('config.type', default='Expression', deserializable=False) module_type = _properties.String('module_type', default='PREDICTOR') def __init__(self, name: str, description: str, expression: str, output: RealDescriptor, aliases: Optional[Mapping[str, str]] = None, archived: bool = False): warn("{this_class} is deprecated. Please use {replacement} instead". format(this_class=self.__class__.__name__, replacement=ExpressionPredictor.__name__)) self.name: str = name self.description: str = description self.expression: str = expression self.output: RealDescriptor = output self.aliases: Optional[Mapping[str, str]] = aliases self.archived: bool = archived def _post_dump(self, data: dict) -> dict: data['display_name'] = data['config']['name'] return data def __str__(self): return '<DeprecatedExpressionPredictor {!r}>'.format(self.name)
class MeanPropertyPredictor(Resource['MeanPropertyPredictor'], Predictor, AIResourceMetadata): """A predictor interface that computes mean component properties. .. seealso:: If you are using a deprecated generalized mean property predictor please see :class:`~citrine.informatics.predictors.generalized_mean_property_predictor.GeneralizedMeanPropertyPredictor` for details on how to migrate to the new format. Parameters ---------- name: str name of the configuration description: str description of the predictor input_descriptor: FormulationDescriptor descriptor that represents the input formulation properties: List[RealDescriptor] List of descriptors to featurize p: int Power of the `generalized mean <https://en.wikipedia.org/wiki/Generalized_mean>`_. Only integer powers are supported. impute_properties: bool Whether to impute missing ingredient properties. If ``False`` all ingredients must define values for all featurized properties. Otherwise, the row will not be featurized. If ``True`` and no ``default_properties`` are specified, then the average over the entire dataset is used. If ``True`` and a default is specified in ``default_properties``, then the specified default is used in place of missing values. label: Optional[str] Optional label training_data: Optional[List[DataSource]] Sources of training data. Each can be either a CSV or an GEM Table. Candidates from multiple data sources will be combined into a flattened list and de-duplicated by uid and identifiers. De-duplication is performed if a uid or identifier is shared between two or more rows. The content of a de-duplicated row will contain the union of data across all rows that share the same uid or at least 1 identifier. Training data is unnecessary if the predictor is part of a graph that includes all training data required by this predictor. default_properties: Optional[Mapping[str, float]] Default values to use for imputed properties. Defaults are specified as a map from descriptor key to its default value. If not specified and ``impute_properties == True`` the average over the entire dataset will be used to fill in missing values. Any specified defaults will be used in place of the average over the dataset. ``impute_properties`` must be ``True`` if ``default_properties`` are provided. """ _resource_type = ResourceTypeEnum.MODULE input_descriptor = _properties.Object(FormulationDescriptor, 'config.input') properties = _properties.List(_properties.Object(RealDescriptor), 'config.properties') p = _properties.Integer('config.p') training_data = _properties.List(_properties.Object(DataSource), 'config.training_data') impute_properties = _properties.Boolean('config.impute_properties') default_properties = _properties.Optional( _properties.Mapping(_properties.String, _properties.Float), 'config.default_properties') label = _properties.Optional(_properties.String, 'config.label') typ = _properties.String('config.type', default='MeanProperty', deserializable=False) module_type = _properties.String('module_type', default='PREDICTOR') def __init__(self, name: str, description: str, input_descriptor: FormulationDescriptor, properties: List[RealDescriptor], p: int, impute_properties: bool, default_properties: Optional[Mapping[str, float]] = None, label: Optional[str] = None, training_data: Optional[List[DataSource]] = None, archived: bool = False): self.name: str = name self.description: str = description self.input_descriptor: FormulationDescriptor = input_descriptor self.properties: List[RealDescriptor] = properties self.p: int = p self.training_data: List[DataSource] = self._wrap_training_data( training_data) self.impute_properties: bool = impute_properties self.default_properties: Optional[Mapping[str, float]] = default_properties self.label: Optional[str] = label self.archived: bool = archived def _post_dump(self, data: dict) -> dict: data['display_name'] = data['config']['name'] return data def __str__(self): return '<MeanPropertyPredictor {!r}>'.format(self.name)
class FormulationDesignSpace(Resource['FormulationDesignSpace'], DesignSpace, AIResourceMetadata): """Design space composed of mixtures of ingredients. Parameters ---------- name: str the name of the design space description: str the description of the design space formulation_descriptor: FormulationDescriptor descriptor used to store formulations sampled from the design space ingredients: Set[str] set of ingredient names that can be used in a formulation constraints: Set[IngredientConstraint] set of constraints that restricts formulations sampled from the space. This must include an :class:`~io.citrine.informatics.constraints.ingredient_count_constraint.IngredientCountConstraint` with maximum count of 32 or fewer. labels: Optional[Mapping[str, Set[str]]] map from a label to each ingredient that should given that label when it's included in a formulation, e.g., ``{'solvent': {'water', 'alcohol'}}`` resolution: float, optional Minimum increment used to specify ingredient quantities. Default is 0.0001. """ _resource_type = ResourceTypeEnum.MODULE formulation_descriptor = properties.Object( FormulationDescriptor, 'config.formulation_descriptor') ingredients = properties.Set(properties.String, 'config.ingredients') labels = properties.Optional( properties.Mapping(properties.String, properties.Set(properties.String)), 'config.labels') constraints = properties.Set(properties.Object(Constraint), 'config.constraints') resolution = properties.Float('config.resolution') typ = properties.String('config.type', default='FormulationDesignSpace', deserializable=False) module_type = properties.String('module_type', default='DESIGN_SPACE', deserializable=False) def __init__(self, *, name: str, description: str, formulation_descriptor: FormulationDescriptor, ingredients: Set[str], constraints: Set[Constraint], labels: Optional[Mapping[str, Set[str]]] = None, resolution: float = 0.0001, session: Session = Session()): self.name: str = name self.description: str = description self.formulation_descriptor: FormulationDescriptor = formulation_descriptor self.ingredients: Set[str] = ingredients self.constraints: Set[Constraint] = constraints self.labels: Optional[Mapping[str, Set[str]]] = labels self.resolution: float = resolution self.session: Session = session def _post_dump(self, data: dict) -> dict: data['display_name'] = data['config']['name'] return data def __str__(self): return '<FormulationDesignSpace {!r}>'.format(self.name)
class IngredientsToSimpleMixturePredictor( Resource['IngredientsToSimpleMixturePredictor'], Predictor, AIResourceMetadata): """[DEPRECATED] Constructs a simple mixture from ingredient quantities. This predictor has been renamed. Please use :class:`~citrine.informatics.predictors.ingredients_to_formulation_predictor.IngredientsToFormulationPredictor` instead. .. seealso:: :class:`~citrine.informatics.predictors.ingredients_to_formulation_predictor.IngredientsToFormulationPredictor` Parameters ---------- name: str name of the configuration description: str description of the predictor output: FormulationDescriptor descriptor that represents the output formulation id_to_quantity: Mapping[str, RealDescriptor] Map from ingredient identifier to the descriptor that represents its quantity, e.g., ``{'water': RealDescriptor('water quantity', 0, 1, "")}`` labels: Mapping[str, Set[str]] Map from each label to all ingredients assigned that label, when present in a mixture e.g., ``{'solvent': {'water'}}`` """ _resource_type = ResourceTypeEnum.MODULE output = _properties.Object(FormulationDescriptor, 'config.output') id_to_quantity = _properties.Mapping(_properties.String, _properties.Object(RealDescriptor), 'config.id_to_quantity') labels = _properties.Mapping(_properties.String, _properties.Set(_properties.String), 'config.labels') typ = _properties.String('config.type', default='IngredientsToSimpleMixture', deserializable=False) module_type = _properties.String('module_type', default='PREDICTOR') def __init__(self, name: str, description: str, output: FormulationDescriptor, id_to_quantity: Mapping[str, RealDescriptor], labels: Mapping[str, Set[str]], archived: bool = False): warn( "{this_class} has been renamed. Please use {replacement} instead". format(this_class=self.__class__.__name__, replacement="Ingredients To Formulation Predictor"), DeprecationWarning) self.name: str = name self.description: str = description self.output: FormulationDescriptor = output self.id_to_quantity: Mapping[str, RealDescriptor] = id_to_quantity self.labels: Mapping[str, Set[str]] = labels self.archived: bool = archived def _post_dump(self, data: dict) -> dict: data['display_name'] = data['config']['name'] # pragma: no cover return data # pragma: no cover def __str__(self): return '<IngredientsToSimpleMixturePredictor {!r}>'.format( self.name) # pragma: no cover