aegis_sim.submodels.genetics.composite.interpreter

  1"""Interpreter of genomic loci
  2
  3Transforms bool array into an array of numbers.
  4These numbers can be loosely understood as gene activity.
  5"""
  6
  7import numpy as np
  8from aegis_sim import variables
  9
 10
 11class Interpreter:
 12    def __init__(self, BITS_PER_LOCUS, THRESHOLD):
 13
 14        self.BITS_PER_LOCUS = BITS_PER_LOCUS
 15        self.THRESHOLD = THRESHOLD
 16
 17        self.exp_base = 0.5  # Important for _exp
 18        self.binary_exp_base = 0.98  # Important for _binary_exp
 19
 20        # Parameters for the binary interpreter
 21        binary_weights = 2 ** np.arange(self.BITS_PER_LOCUS)[::-1]
 22        self.binary_weights = binary_weights / binary_weights.sum()
 23
 24        # Parameters for the binary switch interpreter
 25        binary_switch_weights = 2 ** np.arange(self.BITS_PER_LOCUS)[::-1]
 26        binary_switch_weights[-1] = 0  # Switch bit does not add to locus value
 27        with np.errstate(invalid="ignore"):
 28            self.binary_switch_weights = binary_switch_weights / binary_switch_weights.sum()
 29        # When BITS_PER_LOCUS is 1, all weights are 0 — that's fine, _binary_switch
 30        # will produce zeros for all "on" loci.
 31
 32        # Parameters for the linear interpreter
 33        linear_weights = np.arange(self.BITS_PER_LOCUS)[::-1] + 1
 34        self.linear_weights = linear_weights / linear_weights.sum()
 35
 36    def call(self, loci, interpreter_kind):
 37        """Exposed method"""
 38
 39        # shape is (n_individuals, ?, bits_per_locus)
 40        assert loci.shape[0] > 0, f"loci.shape[0] is {loci.shape[0]}"
 41        assert loci.shape[2] == self.BITS_PER_LOCUS
 42
 43        method = {
 44            "const1": self._const1,
 45            "single_bit": self._single_bit,
 46            "threshold": self._threshold,
 47            "linear": self._linear,
 48            "binary": self._binary,
 49            "switch": self._switch,
 50            "binary_switch": self._binary_switch,
 51            "uniform": self._uniform,
 52            "exp": self._exp,
 53            "binary_exp": self._binary_exp,
 54        }[interpreter_kind]
 55        interpretome = method(loci)
 56        return interpretome
 57
 58    @staticmethod
 59    def _const1(loci):
 60        return np.ones((len(loci), 1))
 61
 62    @staticmethod
 63    def _single_bit(loci):
 64        return loci[:, :, 0]
 65
 66    def _threshold(self, loci):
 67        """Penna interpreter
 68        Cares only about the first bit of the locus.
 69        """
 70        return (~loci[:, :, 0]).cumsum(-1) < self.THRESHOLD
 71
 72    def _linear(self, loci):
 73        return np.matmul(loci, self.linear_weights)
 74
 75    def _binary(self, loci):
 76        """Interpret locus as a binary number and normalize.
 77
 78        High resolution (can produce 2^bits_per_locus different numbers).
 79        Position-dependent.
 80        """
 81
 82        return np.matmul(loci, self.binary_weights)
 83
 84    @staticmethod
 85    def _switch(loci):
 86        """Return 0 if all bits are 0; 1 if all bits are 1; 0 or 1 randomly otherwise.
 87
 88        Low resolution (can produce 2 different numbers).
 89        Position-independent.
 90        """
 91        sums = loci.mean(2)
 92        rand_values = variables.rng.random(loci.shape[:-1]) < 0.5
 93        return np.select([sums == 0, (sums > 0) & (sums < 1), sums == 1], [0, rand_values, 1])
 94
 95    def _binary_switch(self, loci):
 96        """Interpret first n-1 bits as a binary number if the last bit is 1.
 97
 98        High resolution (can produce 2^(bits_per_locus-1) different numbers).
 99        Position-dependent.
100        """
101        where_on = loci[:, :, -1] == 1  # Loci which are turned on
102        values = np.zeros(loci.shape[:-1], dtype=np.float32)  # Initialize output array with zeros
103        values[where_on] = loci[where_on].dot(
104            self.binary_switch_weights
105        )  # If the locus is turned on, make the value in the output array be the binary value
106        return values
107
108    def _uniform(self, loci):
109        """Return normalized sum of bits.
110
111        Medium resolution (can produce bits_per_locus+1 different numbers).
112        Position-independent.
113        """
114        return loci.sum(-1) / loci.shape[-1]
115
116    def _exp(self, loci):
117        """Return base^total_number_of_zeros.
118
119        Medium resolution (can produce bits_per_locus+1 different numbers).
120        Suitable for generating very small numbers.
121        Position-independent.
122        """
123        return self.exp_base ** np.sum(1 - loci, axis=2)
124
125    def _binary_exp(self, loci):
126        """Return base^binary_value_of_locus
127
128        High resolution (can produce 2^bits_per_locus different numbers).
129        Suitable for generating very small numbers.
130        Position-dependent.
131        """
132        binary = self._binary(loci)
133        return self.binary_exp_base**binary