MultiObjectiveGenomicSubsetMatingProblem#

class pybrops.breed.prot.sel.prob.MultiObjectiveGenomicMatingProblem.MultiObjectiveGenomicSubsetMatingProblem(geno, ploidy, mkrwt, tfreq, ndecn, decn_space, decn_space_lower, decn_space_upper, decn_space_xmap, nobj, obj_wt=None, obj_trans=None, obj_trans_kwargs=None, nineqcv=None, ineqcv_wt=None, ineqcv_trans=None, ineqcv_trans_kwargs=None, neqcv=None, eqcv_wt=None, eqcv_trans=None, eqcv_trans_kwargs=None, **kwargs)[source]#

Bases: MultiObjectiveGenomicMatingProblemMixin, SubsetMateSelectionProblem

docstring for MultiObjectiveGenomicSubsetMatingProblem.

Constructor for MultiObjectiveGenomicSubsetMatingProblem.

Parameters:

geno (numpy.ndarray) –
A genotype matrix of shape (n,p) representing only biallelic loci. One of the two alleles at a locus is coded using a 1. The other allele is coded as a 0. mat holds the counts of the allele coded by 1.

Where:
- n is the number of individuals.
- p is the number of markers.
Example:
```
# matrix of shape (n = 3, p = 4)
geno = numpy.array([[0,2,1,0],
                    [2,2,1,1],
                    [0,1,0,2]])
```
ploidy (Integral) – Number of phases that the genotype matrix mat represents.
tfreq (numpy.ndarray) –
A target allele frequency matrix of shape (p,t).

Where:
- p is the number of markers.
- t is the number of traits.
Example:
```
tfreq = numpy.array([0.2, 0.6, 0.7, 0.5])
```
mkrwt (numpy.ndarray) –
A marker weight coefficients matrix of shape (p,t).

Where:
- p is the number of markers.
- t is the number of traits.
Remarks:
- All values in mkrwt must be non-negative.
ndecn (Integral) – Number of decision variables.
decn_space (numpy.ndarray, None) – An array of shape (2,ndecn) defining the decision space. If None, do not set a decision space.
decn_space_lower (numpy.ndarray, Real, None) – An array of shape (ndecn,) containing lower limits for decision variables. If a Real is provided, construct an array of shape (ndecn,) containing the Real. If None, do not set a lower limit for the decision variables.
decn_space_upper (numpy.ndarray, Real, None) – An array of shape (ndecn,) containing upper limits for decision variables. If a Real is provided, construct an array of shape (ndecn,) containing the Real. If None, do not set a upper limit for the decision variables.
nobj (Integral) – Number of objectives.
obj_wt (numpy.ndarray) – Objective function weights.
obj_trans (Callable, None) – A transformation function transforming a latent space vector to an objective space vector. The transformation function must be of the form: obj_trans(x: numpy.ndarray, **kwargs) -> numpy.ndarray If None, use the identity transformation function: copy the latent space vector to the objective space vector.
obj_trans_kwargs (dict, None) – Keyword arguments for the latent space to objective space transformation function. If None, an empty dictionary is used.
nineqcv (Integral,) – Number of inequality constraints.
ineqcv_wt (numpy.ndarray,) – Inequality constraint violation weights.
ineqcv_trans (Callable, None) – A transformation function transforming a latent space vector to an inequality constraint violation vector. The transformation function must be of the form: ineqcv_trans(x: numpy.ndarray, **kwargs) -> numpy.ndarray If None, use the empty set transformation function: return an empty vector of length zero.
ineqcv_trans_kwargs (Optional[dict],) – Keyword arguments for the latent space to inequality constraint violation space transformation function. If None, an empty dictionary is used.
neqcv (Integral) – Number of equality constraints.
eqcv_wt (numpy.ndarray) – Equality constraint violation weights.
eqcv_trans (Callable, None) – A transformation function transforming a latent space vector to an equality constraint violation vector. The transformation function must be of the form: eqcv_trans(x: numpy.ndarray, **kwargs) -> numpy.ndarray If None, use the empty set transformation function: return an empty vector of length zero.
eqcv_trans_kwargs (dict, None) – Keyword arguments for the latent space to equality constraint violation space transformation function. If None, an empty dictionary is used.
kwargs (dict) – Additional keyword arguments passed to the parent class (SubsetSelectionProblem) constructor.

Methods

`bounds`
`do`
`evalfn`	Evaluate a candidate solution for the given Problem.
`evaluate`
`from_object`	rtype: `MultiObjectiveGenomicMatingProblemMixin`
`has_bounds`
`has_constraints`
`ideal_point`
`latentfn`	Multi-objective genomic mating objective function.
`nadir_point`
`name`
`pareto_front`
`pareto_set`

Attributes

`callback`	A callback function to be called after every evaluation.
`data`	Type of the variable to be evaluated.
`decn_space`	Decision space boundaries.
`decn_space_lower`	Lower boundary of the decision space.
`decn_space_upper`	Upper boundary of the decision space.
`decn_space_xmap`	Decision space cross map.
`elementwise`	Whether the evaluation function should be run elementwise.
`elementwise_func`	A class that creates the function that evaluates a single individual.
`elementwise_runner`	A function that runs the function that evaluates a single individual.
`eqcv_trans`	Function which transforms outputs from `latentfn` to equality constraint violation values.
`eqcv_trans_kwargs`	Keyword arguments for the latent space to equality constraint violation transformation function.
`eqcv_wt`	Equality constraint violation function weights.
`exclude_from_serialization`	attributes which are excluded from being serialized.
`geno`	Genotype matrix of shape (n,p) in {0,1,2} format.
`ineqcv_trans`	Function which transforms outputs from `latentfn` to inequality constraint violation values.
`ineqcv_trans_kwargs`	Keyword arguments for the latent space to inequality constraint violation transformation function.
`ineqcv_wt`	Inequality constraint violation function weights.
`mkrwt`	Marker weights.
`n_constr`
`n_eq_constr`	n_eq_constr.
`n_ieq_constr`	Number of inequality constraints.
`n_obj`	Number of objectives.
`n_var`	Number of decision variables.
`ndecn`	Number of decision variables.
`neqcv`	Number of equality constraint violations.
`nineqcv`	Number of inequality constraint violation functions.
`nlatent`	Number of latent variables.
`nobj`	Number of objectives.
`obj_trans`	Function which transforms outputs from `latentfn` to objective function values.
`obj_trans_kwargs`	Keyword arguments for the latent space to objective space transformation function.
`obj_wt`	Objective function weights.
`ploidy`	ploidy.
`replace_nan_values_by`	replace_nan_values_by.
`strict`	Whether the shapes are checked strictly.
`tfreq`	Target allele frequency.
`thet`	Whether the target allele frequency is heterozygous.
`tmajor`	Whether the target allele frequency is fixation of a major allele.
`tminor`	Whether the target allele frequency is fixation of a minor allele.
`vars`	Variables provided in their explicit form.
`vtype`	The variable type.
`xl`	Lower boundary of the decision space.
`xmap`	Cross selection map array of shape `(s,d)`.
`xu`	Upper boundary of the decision space.

property callback: Callable | None#: A callback function to be called after every evaluation.

property data: dict#: Type of the variable to be evaluated.

property decn_space: ndarray | None#: Decision space boundaries.

property decn_space_lower: ndarray | None#: Lower boundary of the decision space.

property decn_space_upper: ndarray | None#: Upper boundary of the decision space.

property decn_space_xmap: ndarray#: Decision space cross map.

property elementwise: bool#: Whether the evaluation function should be run elementwise.

property elementwise_func: type#: A class that creates the function that evaluates a single individual.

property elementwise_runner: Callable#: A function that runs the function that evaluates a single individual.

property eqcv_trans: Callable[[ndarray, ndarray, dict], ndarray]#: Function which transforms outputs from latentfn to equality constraint violation values.

property eqcv_trans_kwargs: dict#: Keyword arguments for the latent space to equality constraint violation transformation function.

property eqcv_wt: ndarray#: Equality constraint violation function weights.

evalfn(x, *args, **kwargs)#

Evaluate a candidate solution for the given Problem.

This calculates three vectors which are to be minimized:

\[\mathbf{v_{obj}} = \mathbf{w_{obj} \odot T_{obj}(L(x))} \ \mathbf{v_{ineqcv}} = \mathbf{w_{ineqcv} \odot T_{ineqcv}(L(x))} \ \mathbf{v_{eqcv}} = \mathbf{w_{eqcv} \odot T_{eqcv}(L(x))}\]

Parameters:

x (numpy.ndarray) – A candidate solution vector of shape (ndecn,).
args (tuple) – Additional non-keyword arguments.
kwargs (dict) – Additional keyword arguments.

Returns:

out – A tuple (obj, ineqcv, eqcv).

Where:

obj is a numpy.ndarray of shape (nobj,) that contains
objective function evaluations. This is equivalent to \(\mathbf{v_{obj}}\)
ineqcv is a numpy.ndarray of shape (nineqcv,) that contains
inequality constraint violation values. This is equivalent to \(\mathbf{v_{ineqcv}}\)
eqcv is a numpy.ndarray of shape (neqcv,) that contains
equality constraint violation values. This is equivalent to \(\mathbf{v_{eqcv}}\)

Return type:

tuple

property exclude_from_serialization: Iterable | None#: attributes which are excluded from being serialized.

property geno: ndarray#: Genotype matrix of shape (n,p) in {0,1,2} format.

property ineqcv_trans: Callable[[ndarray, ndarray, dict], ndarray]#: Function which transforms outputs from latentfn to inequality constraint violation values.

property ineqcv_trans_kwargs: dict#: Keyword arguments for the latent space to inequality constraint violation transformation function.

property ineqcv_wt: ndarray#: Inequality constraint violation function weights.

latentfn(x, *args, **kwargs)[source]#

Multi-objective genomic mating objective function.

The goal is to minimize all objectives for this function.
This is a bare bones function. Minimal error checking is done.

Objectives: \(F(\textbf{x})\)

\[F(\textbf{x}) = {[f^{\textup{PAU}}(\textbf{x}), f^{\textup{PAFD}}(\textbf{x})]}'\]

Population Allele Unavailability (PAU): \(f^{\textup{PAU}}(\textbf{x})\)

Formal PAU definition:

\[f^{\textup{PAU}}(\textbf{x}) = \textbf{w} \cdot \textbf{u}\]

Given a genotype matrix mat and a selection indices vector \(\textbf{x} =\) sel, calculate the selection allele frequency. From the selection allele frequencies and the target allele frequencies tfreq, determine if the target frequencies can be attained after unlimited generations of selection. If the target allele frequency at a locus cannot be attained, score locus as 1, otherwise score as 0. Store this into a binary score vector \(\textbf{u}\). Take the dot product between the binary score vector and the marker weight vector \(\textbf{w} =\) mkrwt to calculate \(f^{\textup{PAU}}(\textbf{x})\) and return the result.

Population Allele Frequency Distance (PAFD): \(f^{\textup{PAFD}}(\textbf{x})\)

Formal PAFD definition:

\[f^{\textup{PAFD}}(\textbf{x}) = \textbf{w} \cdot \left | \textbf{p}_{x} - \textbf{p}_{t} \right |\]

Given a genotype matrix mat and a selection indices vector \(\textbf{x} =\) sel, calculate the selection allele frequency \(\textbf{p}_{x}\). From the selection allele frequencies and the target allele frequencies \(\textbf{p}_{t} =\) tfreq, calculate the absolute value of the difference between the two vectors. Finally, take the dot product between the difference vector and the marker weight vector \(\textbf{w} =\) mkrwt to calculate \(f^{\textup{PAFD}}(\textbf{x})\) and return the result.

Sum of Progeny Standard Deviations of Additive Variance (SPstdA): \(f^{\textup{SPstdA}}(\textbf{x})\)

Formal SPstdA definition:

\[f^{\textup{SPstdA}}(\textbf{x}) = \sum_{c \in S} \sigma_{A,c}\]

Given a progeny variance matrix \(\Sigma_{A} =\) vmat and a selection indices vector \(\textbf{x} =\) sel, take the sum of the square root of the progeny variance \(\sigma_{A,c} = \sqrt{\Sigma_{A,c}}\) for each cross.

Parameters:

x (numpy.ndarray) – A candidate solution vector of shape (ndecn,).
args (tuple) – Additional non-keyword arguments.
kwargs (dict) – Additional keyword arguments.

Returns:

out – An MOGS matrix of shape (t,).

Where:

t is the number of traits.

Return type:

numpy.ndarray

property mkrwt: ndarray#: Marker weights.

property n_eq_constr: Integral#: n_eq_constr.

property n_ieq_constr: Integral#: Number of inequality constraints.

property n_obj: Integral#: Number of objectives.

property n_var: Integral#: Number of decision variables.

property ndecn: Integral#: Number of decision variables.

property neqcv: Integral#: Number of equality constraint violations.

property nineqcv: Integral#: Number of inequality constraint violation functions.

property nlatent: Integral#: Number of latent variables.

property nobj: Integral#: Number of objectives.

property obj_trans: Callable[[ndarray, ndarray, dict], ndarray]#: Function which transforms outputs from latentfn to objective function values.

property obj_trans_kwargs: dict#: Keyword arguments for the latent space to objective space transformation function.

property obj_wt: ndarray#: Objective function weights.

property ploidy: Integral#: ploidy.

property replace_nan_values_by: Real | None#: replace_nan_values_by.

property strict: bool#: Whether the shapes are checked strictly.

property tfreq: ndarray#: Target allele frequency.

property thet: ndarray#: Whether the target allele frequency is heterozygous.

property tmajor: ndarray#: Whether the target allele frequency is fixation of a major allele.

property tminor: ndarray#: Whether the target allele frequency is fixation of a minor allele.

property vars: Container | None#: Variables provided in their explicit form.

property vtype: type | None#: The variable type. So far, just used as a type hint.

property xl: ndarray | None#: Lower boundary of the decision space.

property xmap: ndarray#: Cross selection map array of shape (s,d).

property xu: ndarray | None#: Upper boundary of the decision space.