Spaces:
Runtime error
Runtime error
File size: 5,855 Bytes
82a7a28 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 |
from typing import Union, List
from tinytroupe.extraction import logger
from tinytroupe.utils import JsonSerializableRegistry
from tinytroupe.experimentation import Proposition
from tinytroupe.environment import TinyWorld
from tinytroupe.agent import TinyPerson
import tinytroupe.utils as utils
# TODO under development
class Intervention:
def __init__(self, targets: Union[TinyPerson, TinyWorld, List[TinyPerson], List[TinyWorld]],
first_n:int=None, last_n:int=5,
name: str = None):
"""
Initialize the intervention.
Args:
target (Union[TinyPerson, TinyWorld, List[TinyPerson], List[TinyWorld]]): the target to intervene on
first_n (int): the number of first interactions to consider in the context
last_n (int): the number of last interactions (most recent) to consider in the context
name (str): the name of the intervention
"""
self.targets = targets
# initialize the possible preconditions
self.text_precondition = None
self.precondition_func = None
# effects
self.effect_func = None
# which events to pay attention to?
self.first_n = first_n
self.last_n = last_n
# name
if name is None:
self.name = self.name = f"Intervention {utils.fresh_id()}"
else:
self.name = name
# the most recent precondition proposition used to check the precondition
self._last_text_precondition_proposition = None
self._last_functional_precondition_check = None
################################################################################################
# Intervention flow
################################################################################################
def __call__(self):
"""
Execute the intervention.
Returns:
bool: whether the intervention effect was applied.
"""
return self.execute()
def execute(self):
"""
Execute the intervention. It first checks the precondition, and if it is met, applies the effect.
This is the simplest method to run the intervention.
Returns:
bool: whether the intervention effect was applied.
"""
logger.debug(f"Executing intervention: {self}")
if self.check_precondition():
self.apply_effect()
logger.debug(f"Precondition was true, intervention effect was applied.")
return True
logger.debug(f"Precondition was false, intervention effect was not applied.")
return False
def check_precondition(self):
"""
Check if the precondition for the intervention is met.
"""
self._last_text_precondition_proposition = Proposition(self.targets, self.text_precondition, first_n=self.first_n, last_n=self.last_n)
if self.precondition_func is not None:
self._last_functional_precondition_check = self.precondition_func(self.targets)
else:
self._last_functional_precondition_check = True # default to True if no functional precondition is set
llm_precondition_check = self._last_text_precondition_proposition.check()
return llm_precondition_check and self._last_functional_precondition_check
def apply_effect(self):
"""
Apply the intervention's effects. This won't check the precondition,
so it should be called after check_precondition.
"""
self.effect_func(self.targets)
################################################################################################
# Pre and post conditions
################################################################################################
def set_textual_precondition(self, text):
"""
Set a precondition as text, to be interpreted by a language model.
Args:
text (str): the text of the precondition
"""
self.text_precondition = text
return self # for chaining
def set_functional_precondition(self, func):
"""
Set a precondition as a function, to be evaluated by the code.
Args:
func (function): the function of the precondition.
Must have the a single argument, targets (either a TinyWorld or TinyPerson, or a list). Must return a boolean.
"""
self.precondition_func = func
return self # for chaining
def set_effect(self, effect_func):
"""
Set the effect of the intervention.
Args:
effect (str): the effect function of the intervention
"""
self.effect_func = effect_func
return self # for chaining
################################################################################################
# Inspection
################################################################################################
def precondition_justification(self):
"""
Get the justification for the precondition.
"""
justification = ""
# text precondition justification
if self._last_text_precondition_proposition is not None:
justification += f"{self._last_text_precondition_proposition.justification} (confidence = {self._last_text_precondition_proposition.confidence})\n\n"
# functional precondition justification
elif self._last_functional_precondition_check == True:
justification += f"Functional precondition was met.\n\n"
else:
justification += "Preconditions do not appear to be met.\n\n"
return justification
|