Python Chainer.forward_step方法代码示例

# 需要导入模块: from pln.chainers import Chainer [as 别名]
# 或者: from pln.chainers.Chainer import forward_step [as 别名]
class InferenceAgent(MindAgent):
    def __init__(self):
        self.chainer = None

    def create_chainer(self, atomspace):
        self.chainer = Chainer(atomspace, stimulateAtoms=False)

        # EvaluationToMember, MemberToInheritance
        self.chainer.add_rule(EvaluationToMemberRule(self.chainer))
        self.chainer.add_rule(MemberToEvaluationRule(self.chainer))
        self.chainer.add_rule(MemberToInheritanceRule(self.chainer))
        self.chainer.add_rule(InheritanceToMemberRule(self.chainer))

        # For predicates with 2 arguments,
        # with the 0th argument made into a variable
        self.chainer.add_rule(
            GeneralEvaluationToMemberRule(self.chainer, 0, 2))

        # ModusPonens:
        # Implication smokes(x) cancer(X)
        # smokes(Anna)
        # |= cancer(Anna)
        self.chainer.add_rule(
            ModusPonensRule(self.chainer, types.ImplicationLink))

    def run(self, atomspace):
        if self.chainer is None:
            self.create_chainer(atomspace)
            return

        result = self.chainer.forward_step()
        return result

# 需要导入模块: from pln.chainers import Chainer [as 别名]
# 或者: from pln.chainers.Chainer import forward_step [as 别名]
class SyllogismAgent(MindAgent):
    def __init__(self):
        self.chainer = None

    def create_chainer(self, local_atomspace):
        self.chainer = Chainer(
            local_atomspace,
            agent=self,
            stimulateAtoms=False,
            # can be set to True to use AA on syllogisms
            preferAttentionalFocus=False,
            allow_output_with_variables=True,
            delete_temporary_variables=True,
        )
        # add rules here
        # self.chainer.add_rule()

    def run(self, local_atomspace):
        if self.chainer is None:
            self.create_chainer(local_atomspace)
            print ("PLN Chainer created.")
            return

        print ("PLN continuing.")

        result = self.chainer.forward_step()
        return result

# 需要导入模块: from pln.chainers import Chainer [as 别名]
# 或者: from pln.chainers.Chainer import forward_step [as 别名]
class DeductionAgent(MindAgent):
    def __init__(self):
        self.chainer = None

    def create_chainer(self, atomspace):
        self.chainer = Chainer(atomspace, stimulateAtoms=False)

        link_types = [types.InheritanceLink]

        for link_type in link_types:
            self.chainer.add_rule(DeductionRule(self.chainer, link_type))

    def run(self, atomspace):
        # Run is invoked on every cogserver cognitive cycle
        # If it is the first time it has been invoked, then the chainer
        # needs to be created
        if self.chainer is None:
            self.create_chainer(atomspace)
            return

        result = self.chainer.forward_step()

        if __VERBOSE__:
            print result

        return result

    def get_trails(self):
        return self.chainer.trails

    def get_history(self):
        return self.chainer.history.get_history()

# 需要导入模块: from pln.chainers import Chainer [as 别名]
# 或者: from pln.chainers.Chainer import forward_step [as 别名]
class DeceptionAgent(MindAgent):
    def __init__(self):
        self.chainer = None
        print "Initialized DeceptionAgent."

    def create_chainer(self, atomspace, stimulate_atoms=False):
        self.chainer = Chainer(atomspace,
                               agent=self,
                               stimulateAtoms=stimulate_atoms,
                               allow_output_with_variables=False,
                               delete_temporary_variables=True)

        self.chainer.add_rule(
            ModusPonensRule(self.chainer, types.ImplicationLink))

    def run(self, atomspace):
        if self.chainer is None:
            self.create_chainer(atomspace)
            return

        result = self.chainer.forward_step()

        # if __VERBOSE__:
        #     print result

        return result

    def get_trails(self):
        return self.chainer.trails

    def get_history(self):
        return self.chainer.history.get_history()

# 需要导入模块: from pln.chainers import Chainer [as 别名]
# 或者: from pln.chainers.Chainer import forward_step [as 别名]
class InferenceAgent(MindAgent):
    def __init__(self):
        self.chainer = None
        print "Initializing InferenceAgent."

    def create_chainer(self, atomspace, stimulate_atoms=True):
        self.chainer = Chainer(atomspace,
                               agent=self,
                               stimulateAtoms=stimulate_atoms,
                               allow_output_with_variables=False,
                               preferAttentionalFocus=True,
                               delete_temporary_variables=True)

        # ModusPonens:
        # Implication smokes(x) cancer(X)
        # smokes(Anna)
        # |= cancer(Anna)
        self.chainer.add_rule(
            ModusPonensRule(self.chainer, types.ImplicationLink))

    def run(self, atomspace):
        if self.chainer is None:
            self.create_chainer(atomspace)
            print "PLN Chainer created."
            return

        print "PLN continuing."

        target = atomspace[scheme_eval_h(atomspace, "query")]

        if not check_result(atomspace):
            result = self.chainer.forward_step()
            self.chainer._give_stimulus(target, TARGET_STIMULUS)

            return result

# 需要导入模块: from pln.chainers import Chainer [as 别名]
# 或者: from pln.chainers.Chainer import forward_step [as 别名]
class SocratesAgent(MindAgent):
    def __init__(self):
        self.chainer = None

    def create_chainer(self, atomspace):
        self.chainer = Chainer(atomspace,
                               #stimulates atoms (stimulus of 10 at the moment)
                               stimulateAtoms=True,
                               #agent selects atoms with higher stis
                               preferAttentionalFocus=False,
                               allow_output_with_variables=True,
                               delete_temporary_variables=True)

        self.chainer.add_rule(
            GeneralEvaluationToMemberRule(self.chainer, 0, 2))
        self.chainer.add_rule(MemberToInheritanceRule(self.chainer))
        self.chainer.add_rule(
            DeductionRule(self.chainer, types.InheritanceLink))
        self.chainer.add_rule(
            InheritanceToMemberRule(self.chainer))
        self.chainer.add_rule(
            MemberToEvaluationRule(self.chainer))
        self.chainer.add_rule(
            AbductionRule(self.chainer, types.InheritanceLink))

    def run(self, atomspace):
        if self.chainer is None:
            self.create_chainer(atomspace)
            return

        result = self.chainer.forward_step()
        return result

# 需要导入模块: from pln.chainers import Chainer [as 别名]
# 或者: from pln.chainers.Chainer import forward_step [as 别名]
class InferenceAgent(MindAgent):
    def __init__(self):
        self.chainer = None

    def create_chainer(self, atomspace):
        self.chainer = Chainer(atomspace, stimulateAtoms=False)

        # Note:
        # The API for adding Rules and Links to a PLN Chainer is
        # hard to use. It could be redesigned so that you would
        # just pass a list of rule types and link types when you
        # instantiate the Chainer, without having to be aware of
        # the different sets of rules that require different
        # argument sets.

        for rule in RULES_CHAINER_LINKTYPE:
            for link_type in LINK_TYPES:
                print rule, link_type
                self.chainer.add_rule(rule(self.chainer, link_type))

        for rule in RULES_CHAINER:
            self.chainer.add_rule(rule(self.chainer))

    def run(self, atomspace):
        if self.chainer is None:
            self.create_chainer(atomspace)
            return

        result = self.chainer.forward_step()

        if __VERBOSE__:
            print result

        return result

# 需要导入模块: from pln.chainers import Chainer [as 别名]
# 或者: from pln.chainers.Chainer import forward_step [as 别名]
class ContextAgent(MindAgent):
    def __init__(self):
        self.chainer = None

    def create_chainer(self, atomspace):
        self.chainer = Chainer(atomspace,
                               stimulateAtoms=False,
                               preferAttentionalFocus=False,
                               allow_output_with_variables=True,
                               delete_temporary_variables=True)

        self.chainer.add_rule(InheritanceToContextRule(self.chainer))
        self.chainer.add_rule(EvaluationToContextRule(self.chainer))
        self.chainer.add_rule(SubsetToContextRule(self.chainer))
        self.chainer.add_rule(ContextToInheritanceRule(self.chainer))
        self.chainer.add_rule(ContextToEvaluationRule(self.chainer))
        self.chainer.add_rule(ContextToSubsetRule(self.chainer))
        self.chainer.add_rule(ContextFreeToSensitiveRule(self.chainer))

    def run(self, atomspace):
        if self.chainer is None:
            self.create_chainer(atomspace)
            return

        result = self.chainer.forward_step()
        return result

# 需要导入模块: from pln.chainers import Chainer [as 别名]
# 或者: from pln.chainers.Chainer import forward_step [as 别名]
class EvaluationToMemberAgent(MindAgent):
    def __init__(self):
        self.chainer = None

    def create_chainer(self, atomspace):
        self.chainer = Chainer(atomspace,
                               stimulateAtoms=False,
                               allow_output_with_variables=True,
                               delete_temporary_variables=True)

        self.chainer.add_rule(
            GeneralEvaluationToMemberRule(self.chainer, 0, 2))
        self.chainer.add_rule(MemberToInheritanceRule(self.chainer))
        self.chainer.add_rule(
            DeductionRule(self.chainer, types.InheritanceLink))
        self.chainer.add_rule(
            InheritanceToMemberRule(self.chainer))
        self.chainer.add_rule(
            MemberToEvaluationRule(self.chainer))

    def run(self, atomspace):
        if self.chainer is None:
            self.create_chainer(atomspace)
            return

        result = self.chainer.forward_step()
        return result

# 需要导入模块: from pln.chainers import Chainer [as 别名]
# 或者: from pln.chainers.Chainer import forward_step [as 别名]
class InferenceAgent(MindAgent):
    def __init__(self):
        self.chainer = None

    def create_chainer(self, atomspace, stimulate_atoms=True):
        self.chainer = Chainer(atomspace,
                               agent=self,
                               stimulateAtoms=stimulate_atoms,
                               allow_output_with_variables=False,
                               preferAttentionalFocus=True,
                               delete_temporary_variables=True)

        # ModusPonens:
        # Implication smokes(x) cancer(X)
        # smokes(Anna)
        # |= cancer(Anna)
        self.chainer.add_rule(
            ModusPonensRule(self.chainer, types.ImplicationLink))

    def run(self, atomspace):
        if self.chainer is None:
            self.create_chainer(atomspace)
            return

        if not check_result(atomspace):
            result = self.chainer.forward_step()
            return result

# 需要导入模块: from pln.chainers import Chainer [as 别名]
# 或者: from pln.chainers.Chainer import forward_step [as 别名]
class InferenceAgent(MindAgent):
    def __init__(self):
        self.chainer = None
        self.query = None
        print "Initializing InferenceAgent."

    def create_chainer(self, atomspace, stimulate_atoms=True):
        """
        Creates the chainer for the "smokes" example. Optionally, you can
         define the target query before calling this method, by defining a
         Scheme expression named "query". For example, you can issue the
         Scheme expression "(define query hasCancer)" in reference to the
         predicate defined in smokes.scm before loading this agent. Once
         defined, the target query will receive stimulus at every time step.
         Stimulus requires the agent to be running in a CogServer.
         For a complete example that incorporates this behavior, see
         example.py here:
           https://github.com/opencog/external-tools/tree/master/attention
        """
        self.chainer = Chainer(atomspace,
                               agent=self,
                               stimulateAtoms=stimulate_atoms,
                               allow_output_with_variables=False,
                               preferAttentionalFocus=True,
                               delete_temporary_variables=True)

        # ModusPonens:
        # Implication smokes(x) cancer(X)
        # smokes(Anna)
        # |= cancer(Anna)
        self.chainer.add_rule(
            ModusPonensRule(self.chainer, types.ImplicationLink))

        # stimulateAtoms is only enabled when the agent is ran inside the
        # CogServer, since the functionality requires a CogServer and
        # attention allocation
        if self.chainer._stimulateAtoms:
            self.query = scheme_eval_h(atomspace, "query")

    def run(self, atomspace):
        if self.chainer is None:
            self.create_chainer(atomspace)
            print "PLN Chainer created."
            return

        print "PLN continuing."

        if not check_result(atomspace):
            result = self.chainer.forward_step()

            if self.query is not None:
                self.chainer._give_stimulus(atomspace[self.query],
                                            TARGET_STIMULUS)

            return result

# 需要导入模块: from pln.chainers import Chainer [as 别名]
# 或者: from pln.chainers.Chainer import forward_step [as 别名]
class InferenceAgent(MindAgent):
    def __init__(self):
        self.chainer = None
        self.antecedents = []

    def create_chainer(self, atomspace):
        self.chainer = Chainer(atomspace,
                               agent=self,
                               stimulateAtoms=True,
                               preferAttentionalFocus=True,
                               delete_temporary_variables=True,
                               allow_output_with_variables=True)

        self.chainer.add_rule(
            ModusPonensRule(self.chainer, types.ImplicationLink))

    def run(self, atomspace):
        if self.chainer is None:
            self.create_chainer(atomspace)

            implications = atomspace.get_atoms_by_type(types.ImplicationLink)
            for implication in implications:
                outgoing = atomspace.get_outgoing(implication.h)
                and_link = outgoing[0]
                self.antecedents.append(and_link)

            return

        # Run a forward step of the chainer with the ModusPonensRule so as to
        # perform inference using the "domain rules" defined as
        # ImplicationLinks
        self.chainer.forward_step()

        # Run a backward step of the chainer with the AndCreationRule for each
        # of the antecedents of the defined "domain rules" so as to
        # successfully ground the variables.
        for antecedent in self.antecedents:
            num_predicates = len(atomspace.get_outgoing(antecedent.h))
            self.chainer.backward_step(
                AndCreationRule(self.chainer, num_predicates), [antecedent])

        return

# 需要导入模块: from pln.chainers import Chainer [as 别名]
# 或者: from pln.chainers.Chainer import forward_step [as 别名]
class InferenceAgent(MindAgent):
    def __init__(self):
        self.chainer = None

    def create_chainer(self, atomspace):
        self.chainer = Chainer(atomspace, stimulateAtoms=False)

        self.chainer.add_rule(
            ModusPonensRule(self.chainer, types.ImplicationLink))

    def run(self, atomspace):
        if self.chainer is None:
            self.create_chainer(atomspace)
            return

        result = self.chainer.forward_step()
        return result

# 需要导入模块: from pln.chainers import Chainer [as 别名]
# 或者: from pln.chainers.Chainer import forward_step [as 别名]
class TemporalAgent(MindAgent):
    def __init__(self):
        self.chainer = None

    def create_chainer(self, atomspace):
        self.chainer = Chainer(atomspace,
                               stimulateAtoms=False,
                               preferAttentionalFocus=False,
                               allow_output_with_variables=True,
                               delete_temporary_variables=True)

        for rule in create_temporal_rules(self.chainer):
            self.chainer.add_rule(rule)

    def run(self, atomspace):
        if self.chainer is None:
            self.create_chainer(atomspace)
            return

        result = self.chainer.forward_step()
        return result

# 需要导入模块: from pln.chainers import Chainer [as 别名]
# 或者: from pln.chainers.Chainer import forward_step [as 别名]
class EvaluationToMemberAgent(MindAgent):
    def __init__(self):
        self.chainer = None

    def create_chainer(self, atomspace):
        self.chainer = Chainer(atomspace, stimulateAtoms=False)

        # EvaluationToMemberRule only accepts predicates with 1 argument
        # For predicates with more arguments, GeneralEvaluationToMemberRule
        # is used.
        self.chainer.add_rule(
            GeneralEvaluationToMemberRule(self.chainer, 0, 2))
        self.chainer.add_rule(MemberToInheritanceRule(self.chainer))
        self.chainer.add_rule(
            DeductionRule(self.chainer, types.InheritanceLink))

    def run(self, atomspace):
        if self.chainer is None:
            self.create_chainer(atomspace)
            return

        result = self.chainer.forward_step()
        return result