readme.txt

来自「aiParts is a set of C++ classes that can」· 文本 代码 · 共 493 行 · 第 1/2 页

   problem-domain-specific aspects plus strategic aspects.

 - After each try, change the relevant strategic aspects 
   to reflect the result of the try. 

The technique is chaotically sensitive to initial conditions,
parameters and the sequence of random numbers used for 
choosing equal options. A tiny change can result in a 
different choice in a try, which may affect subsequent
choices and tries.

= = = = = = = = = = = = = = = =
    Hope Combines Aspects

Hope is the result of the evaluation of all aspects being 
considered.  Option-hope is a single quantity that can be 
used to compare options.

The hope associated with an option combines the results of 
the evaluation of... 

 - static aspects ("It's good for Bill to work evenings.)"

 - dynamic aspects based on decisions made up to this point 
   ("It would be bad for Sally to work today; she has already 
    worked five days in a row.")

 - strategic aspects based on what has been learned in 
   previous tries ("This option worked really well last 
   time.")

Static and dynamic aspects are particular to the problem 
domain. For each aspect, you write a bit of code that 
evaluates the aspect and assigns a goodness value.

The strategic aspects are handled by the High-Hope classes. 
You create subclasses for the objects in your problem. An 
application assembles a problem using these subclasses. 

= = = = = = = = = = = = = = = =
    Fear, Greed and Curiosity

In the High-Hope technique, the strategic aspects are 
emotions. The use of the word "emotion" and the names of 
the emotions are misleading because the words have 
multiple subtle meanings.

The strategic aspects that contribute to hope are:

     Fear is the feeling that something bad may happen. 
     Fear causes you to avoid an option that has been a 
     problem in the past. Fear starts at Neutral and 
     becomes more negative as an option is involved in 
     unsuccessful tries.

    Greed is the feeling that you know how to make 
    something good happen.  Greed attracts you to options 
    that have worked well in the past. Greed starts at 
    Neutral and becomes more positive as an option is 
    involved in successful tries.

    Curiosity is the feeling that an untried option might 
    be good. Curiosity attracts you to options that might 
    turn out even better than any you have already tried. 
    Curiosity about an apparently acceptable option starts 
    fairly high and decreases as the option is tried. 

Hope = Fear + Greed + Curiosity

= = = = = = = = = = = = = = = =
    Hope is a Sum

A hope resolves to a goodness. Aspects that contribute to 
a hope resolve to a goodnesses. Aspects can be combined by 
adding, if goodnesses are implemented like...

    VeryVeryBad       =   -1024
    VeryBad           =    -512
    QuiteBad          =    -256
    Bad               =     -64
    FairlyBad         =     -32
    SomewhatBad       =      -8
    SlightlyBad       =      -2
    VerySlightlyBad   =      -1
    Neutral           =       0
    VerySlightlyGood  =       1
    SlightlyGood      =       2
    SomewhatGood      =       3
    FairlyGood        =       4
    Good              =       5
    QuiteGood         =       6
    VeryGood          =       7
    VeryVeryGood      =       8

The lack of symmetry around Neutral is a reflection of the 
fact that the worse an aspect is, the more important it is. 
There may be, for example, a variety of good aspects to 
setting the alarm clock an hour later, but if one of them
is probably getting fired, it's probably a bad option.


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
        aiParts Source Files

Files generally depend on the files above it in this list...

  Low-Level Types, Base Class and Utility Classes:
    aipTime.h          Time and date
    aipGood.h          Goodness
    aipBase.h          base class, messages, random numbers

  Classes that implement AI Patterns:
    aipPandemonium.h   Pandemonium, demons
    aipEmotion.h       Emotion - Fear, Greed, Curiosity, Hope

  Classes for Decision-Making and Problem-Solving:
    aipDecision.h      Decisions, options
    aipProblem.h       Problems

  Classes that implement AI techniques:
    aipHighHope.h      High-Hope problem-solving

  Classes that specialize AI techniques:
    aipReqRes.h        Requirement-Resource frame-work

                  Files for Sample Programs

samp_time.cpp          Using the date and time classes
samp_good.cpp          Using the goodness class
samp_pandemonium.cpp   Using the container class
samp_decision.cpp      Making decisions using an emotion
   samp_deer_fear.h
   samp_deer_fear.cpp
samp_a_to_b.cpp        Navigating using the High-Hope classes
   samp_a2b.h
   samp_a2b.cpp


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
        The aiParts Open Source Project

aiParts is an Open Source project that develops software
parts that implement artificial intelligence.

The software distributed by this project is copyrighted by
its authors and then licensed with the MIT License and as
such, it is OSI Certified Open Source Software.

See the file LICENSE.txt.

This means that you can do pretty much whatever you want
with aiParts software... use it, distribute it, build it
into other software, whatever.

When you get aiParts software, you get the source code.
You have control of your software (regardless of what
this project does in the future).

Contributions are always welcome: software, documentation,
testing, suggestions, bug reports, enhancement requests,
comments and criticism. See the last section of this file.

aiParts is currently focused on the High-Hope technique
for multi-decision problems.  Anyone is welcome to 
contribute software parts that implement other approaches
to artificial intelligence.

For more information, contact Brian Marshall at:
   [e-mail]

See www.opensource.org for information on the 
Open Source Initiative.

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
        Future Development Notes

Make the A-to-B sample program problem bigger and harder.

Developing new AI techniques (alternatives to the High-Hope
technique)

Developing abstraction-layers for an AI technique (just as
the classes in aipReqRes.h/cpp specialize the High-Hope
technique for Requirement-Resource problems)

Recognize and support 'trivial' decisions to provide for:
 - better performance
 - selecting a decision and choosing an option for a 
   resource (rather than for a requirement) and the 
   decision can be (set to be) trivial so the pre-chosen 
   will be chosen.

aipTime.h/cpp: add seconds to class aipTimeOfDay

There is much that can be done to improve the High-Hope AI: 
 - improve the choice of which decision to decide next
 - improve the behavior in the exploring stage
 - maybe add an initial feeling-out stage
 - improve the refining stage
 - analyze the output for sequences and cycles
 - improve how the AI gets out of ruts
 - further improvement of the way hope works
 - and many other ways of refining the AI

   Handling Failure
Maybe: If a try fails, decisions and options later in the 
solution get more fear than those earlier in the solution.

   Good But Different
Recognize when a good result is significantly different from
other good results found.

   Handling Good Improvements
After a recent try that was a good-improvement, increase 
the curiosity of acceptable-looking options that look like 
they would have a significant effect on the solution.  A 
"good-improvement" is a try that is better than the current 
best-so-far try or acceptably good and significantly different
than the best-so-far try.

   Problem-Hope
The problem itself could have a hope which affects how option
hopes are determined.  The idea is that if problem-curiosity is 
high, the aspects that control curiosity in options would be 
given more weight.  The same principle would apply to fear and 
greed.  This would allow for higher curiosity (and more 
exploration) early in the problem-solving, and lower curiosity 
(and more optimization) later in the problem-solving.

   Finding Best Path When on New Path
If following a new path and come to the best-so-far path, 
keep following the bsf path.  This could be done with 
problem-hope; when a node in the bsf solution is chosen, 
drop problem-curiosity to (near) aipNeurtal.

   Implement Ways
A 'way' is a set of options chosen for a set of decisions.
Maybe, in a try, force some ways while exploring other ways.
Ways are a very rich abstraction - they can make it possible
to work on parts of a problem while keeping other parts
constant.  Ways may be the key to recognizing similar solutions.


=================================================================