AI-ExpertSystem-Advanced
view release on metacpan or search on metacpan
During the forward algorithm the task is to find a list of goals
caused by these initial facts (the only data we have in that
moment).
Lets imagine your knowledge database is about symptoms and diseases.
You need to find what diseases are caused by the symptoms of a
patient, these first symptons are the initial facts.
Initial facts as also asked and inference facts can be negative or
positive. By default the initial facts are positive.
Keep in mind that the data contained in this array can be the IDs or
the name of the fact.
This array will be converted to initial_facts_dict. And all the data
(ids or or names) will be made of only IDs.
my $ai = AI::ExpertSystem::Advanced->new(
viewer_class => 'terminal',
knowledge_db => $yaml_kdb,
Keeps a record of all the rules the algorithms have visited and also
the number of causes each rule has.
verbose
my $ai = AI::ExpertSystem::Advanced->new(
viewer_class => 'terminal',
knowledge_db => $yaml_kdb,
initial_facts => ['I'],
verbose => 1);
By default this is turned off. If you want to know what happens
behind the scenes turn this on.
Everything that needs to be debugged will be passed to the debug()
method of your viewer.
viewer
Is the object AI::ExpertSystem::Advanced will be using for printing
what is happening and for interacting with the user (such as asking
the asked_facts).
of this weight.
The match factor is used by the mixed() algorithm and is useful to know
if a certain rule should be shoot or not even if not all of the causes
exist in our facts.
The *match factor* is calculated in two ways:
* Will do a sum of the weight for each matched cause. Please note that
if only one cause of a rule has a specified weight then the
remaining causes will default to the total weight minus 1 and then
divided with the total number of causes (matched or not) that don't
have a weight.
* If no weight is found with all the causes of the given rule, then
the total number of matches will be divided by the total number of
causes.
is_goal_in_our_facts($goal)
Checks if the given $goal is in:
inc/Module/Install/Makefile.pm view on Meta::CPAN
sub prompt {
shift;
# Infinite loop protection
my @c = caller();
if ( ++$seen{"$c[1]|$c[2]|$_[0]"} > 3 ) {
die "Caught an potential prompt infinite loop ($c[1]|$c[2]|$_[0])";
}
# In automated testing, always use defaults
if ( $ENV{AUTOMATED_TESTING} and ! $ENV{PERL_MM_USE_DEFAULT} ) {
local $ENV{PERL_MM_USE_DEFAULT} = 1;
goto &ExtUtils::MakeMaker::prompt;
} else {
goto &ExtUtils::MakeMaker::prompt;
}
}
sub makemaker_args {
my $self = shift;
lib/AI/ExpertSystem/Advanced.pm view on Meta::CPAN
A list/set of initial facts the algorithms start using.
During the forward algorithm the task is to find a list of goals caused
by these initial facts (the only data we have in that moment).
Lets imagine your knowledge database is about symptoms and diseases. You need
to find what diseases are caused by the symptoms of a patient, these first
symptons are the initial facts.
Initial facts as also asked and inference facts can be negative or positive. By
default the initial facts are positive.
Keep in mind that the data contained in this array can be the IDs or the name
of the fact.
This array will be converted to L<initial_facts_dict>. And all the data (ids or
or names) will be made of only IDs.
my $ai = AI::ExpertSystem::Advanced->new(
viewer_class => 'terminal',
knowledge_db => $yaml_kdb,
initial_facts => ['I', ['F', '-'], ['G', '+']);
As you can see if you want to provide the sign of a fact, just I<encapsulate>
it in an array, the first item should be the fact and the second one the
sign.
=cut
has 'initial_facts' => (
is => 'rw',
isa => 'ArrayRef[Str]',
default => sub { return []; });
=item B<initial_facts_dict>
This dictionary (see L<AI::ExpertSystem::Advanced::Dictionary> has the sasme
data of L<initial_facts> but with the additional feature(s) of proviing
iterators and a quick way to find elements.
=cut
has 'initial_facts_dict' => (
is => 'ro',
lib/AI/ExpertSystem/Advanced.pm view on Meta::CPAN
From our example of symptoms and diseases lets imagine we have the hypothesis
that a patient has flu, we don't know the symptoms it has, we want the
expert system to keep asking us for them to make sure that our hypothesis
is correct (or incorrect in case there's not enough information).
=cut
has 'goals_to_check' => (
is => 'rw',
isa => 'ArrayRef[Str]',
default => sub { return []; });
=item B<goals_to_check_dict>
Very similar to L<goals_to_check> (and indeed of L<initial_facts_dict>). We
want to make the job easier.
It will be a dictionary made of the data of L<goals_to_check>.
=cut
has 'goals_to_check_dict' => (
lib/AI/ExpertSystem/Advanced.pm view on Meta::CPAN
isa => 'AI::ExpertSystem::Advanced::Dictionary');
=item B<verbose>
my $ai = AI::ExpertSystem::Advanced->new(
viewer_class => 'terminal',
knowledge_db => $yaml_kdb,
initial_facts => ['I'],
verbose => 1);
By default this is turned off. If you want to know what happens behind the
scenes turn this on.
Everything that needs to be debugged will be passed to the L<debug()> method
of your L<viewer>.
=cut
has 'verbose' => (
is => 'rw',
isa => 'Bool',
default => 0);
=item B<viewer>
Is the object L<AI::ExpertSystem::Advanced> will be using for printing what is
happening and for interacting with the user (such as asking the
L<asked_facts>).
This is practical if you want to use a viewer object that is not provided by
L<AI::ExpertSystem::Advanced::Viewer::Factory>.
lib/AI/ExpertSystem/Advanced.pm view on Meta::CPAN
Is the the class name of the L<viewer>.
You can decide to use the viewers L<AI::ExpertSystem::Advanced::Viewer::Factory>
offers, in this case you can pass the object or only the name of your favorite
viewer.
=cut
has 'viewer_class' => (
is => 'rw',
isa => 'Str',
default => 'terminal');
=item B<found_factor>
In your knowledge database you can give different I<weights> to the facts of
each rule (eg to define what facts have more I<priority>). During the
L<mixed()> algorithm it will be checking what causes are found in the
L<inference_facts> and in the L<asked_facts> dictionaries, then the total
number of matches (or total number of certainity factors of each rule) will
be compared versus the value of this factor, if it's higher or equal then the
rule will be triggered.
You can read the documentation of the L<mixed()> algorithm to know the two
ways this factor can be used.
=cut
has 'found_factor' => (
is => 'rw',
isa => 'Num',
default => '0.5');
=item B<shot_rules>
All the rules that are shot are stored here. This is a hash, the key of each
item is the rule id while its value is the precision time when the rule was
shot.
The precision time is useful for knowing when a rule was shot and based on that
you can know what steps it followed so you can compare (or reproduce) them.
lib/AI/ExpertSystem/Advanced.pm view on Meta::CPAN
in our facts.
The I<match factor> is calculated in two ways:
=over 4
=item *
Will do a sum of the weight for each matched cause. Please note that if only
one cause of a rule has a specified weight then the remaining causes will
default to the total weight minus 1 and then divided with the total number
of causes (matched or not) that don't have a weight.
=item *
If no weight is found with all the causes of the given rule, then the total
number of matches will be divided by the total number of causes.
=back
=cut
lib/AI/ExpertSystem/Advanced/Dictionary.pm view on Meta::CPAN
=cut
has 'iterable_array' => (
is => 'ro',
isa => 'ArrayRef');
=head1 Methods
=head2 B<find($look_for, $find_by)>
Looks for a given value (C<$look_for>). By default it will look for the value
by reading the C<id> of each item, however this can be changed by passing
a different hash key (C<$find_by>).
In case there's no match C<undef> is returned.
=cut
sub find {
my ($self, $look_for, $find_by) = @_;
if (!defined($find_by)) {
lib/AI/ExpertSystem/Advanced/KnowledgeDB/Base.pm view on Meta::CPAN
Similar and same concept of C<rules>, but this will have a list (if available)
of what questions should be done to certain facts.
=back
=cut
has 'questions' => (
is => 'ro',
isa => 'HashRef',
default => sub { return {}; });
=head1 Methods
=head2 B<read()>
This method reads the knowledge database. This is the only method you need to
define even if you are going to load the database in memory or if you are
going to query it.
=cut
( run in 0.560 second using v1.01-cache-2.11-cpan-0a6323c29d9 )