🚀 go-pugleaf

From: Thomas Hoppe <HOPPET@tubvm.cs.tu-berlin.de>
To: mod-ki@unido.informatik.uni-dortmund.de
Date: Mon, 21 Oct 91 21:03:23 +0200
Subject: <mod-ki 0778> FG 1.1.3 Maschinelles Lernen - Prolog Algorithmen
Keywords: Software, Prolog, Machine Learning

mod-ki message 0778
************************************************************************
                     Gesellschaft fuer Informatik
                           Fachgruppe 1.1.3

             Special Interest Group on 'Maschine Learing'

            Prolog library of machine learning algorithms


                             Thomas Hoppe
                          Projektgruppe KIT
                    Technische Universitaet Berlin
                          Franklinstr. 28/29
                            1000 Berlin 10
                               Germany

                     hoppet@tubvm.cs.tu-berlin.de

The  following  algorithms are currently available  from  the  library
(last up-date 21.10.91):


1. Learning Algorithms

  AQ1
     aq1.pro      - Jeffrey M.  Becker's AQ-PROLOG, a reimplementation
                    of Michalski's AQ for attribute vectors
     aq1_1.pro    - Simple Example for AQ
     aq1_2.pro    - Extension of AQ_1.PRO

  ARCH1
     arch1.pro    - Stefan Wrobel's implementation of Winston's incre-
                    mental learning procedure for structural  descrip-
                    tions
     arch1_1.pro  - Winston's example archs

  ARCH2
     arch2.pro    - Ivan Bratko's minimal implementation of  Winston's
                    incremental  learning  procedure  for   structural
                    descriptions
     arch2_1.pro  - simple example archs

  ATTDSC
     attdsc.pro   - Ivan Bratko's simple algorithm for learning attri-
                    butional descriptions
     attdsc_1.pro - Small  example  set  for  learning  to   recognize
                    objects from their silhouettes

  COBWEB
     cobweb.pro   - Joerg-Uwe   Kietz's  implementation  of   Fisher's
                    incremental concept formation algorithm
     cobweb_1.pro - a simple data set describing some hotels

  DISCR
     discr.pro    - Pavel  Brazdil's generation of discriminants  from
                    derivation trees
     discr_1.pro  - Simple abstract example
     discr_2.pro  - Abstract example generating useful and not  useful
                    discriminants

  MULTAGNT
     multagnt.pro - Yiu Cheung HO's implementation of Brazdil's tutor-
                    ing setting
     teacher.pro  - Teacher's knowledge base
     learner1.pro - A correct Learner's knowledge base
     learner2.pro - An erroneous Learner's knowledge base
     calls_1.pro  - Example calls concerning correct knowledge
     calls_2.pro  - Example calls concerning wrong knowledge

  ID3
     idt.pro      - Luis  Torgo's  ID3-like program for  induction  of
                    decision trees based on the gain-ratio measure
     idt_1.pro    - Abstract example
     idt_2.pro    - Credit assignment example producing trivial  clas-
                    sification
     idt_3.pro    - Credit  assignment example  producing  non-trivial
                    classification

  INVERS
     invers.pro   - Implementation  of Steven  Muggleton's  absorption
                    and intra-construction operators for inverse reso-
                    lution based on the representation change idea  of
                    Celine Rouveirol and Jean-Francois Puget
     invers_1.pro - Example call's

  LOGIC
     logic.pro    - Steven Muggleton's implementations of substitution
                    matching,  Plotkin's term generalisations and Wray
                    Buntine's generalized subsumption
     logic_1.pro  - Example call's

  EBG
     ebg.pro      - Basic algorithms for explanation based generalisa-
                    tion and partial evaluation based on Kedar-Cabelli
                    & McCarty's idea. Different kinds of simple PROLOG
                    meta-interpreters.
     ebg_1.pro    - Suicide example for EBG
     ebg_2.pro    - Safe_to_stack example for EBG

  VS
     vs.pro       - Luc  de  Raeth's  reimplementation  of  Mitchell's
                    version space strategy
     vs_1.pro     - A simple shape and color taxonomy


2. Updates

  COBWEB
     cobweb.pro   - Joerg-Uwe  Kietz has  detected  a  fault  in   the
                    current  implementation.  In  the  near  future  a
                    corrected version will be available.

     cobweb_1.pro - Will  be  substituted  by  a  smaller  and  better
                    understandable example.


3. In preparation

  MIS             - Shapiro's Modell Inference System
  AQ2             - Stefan Wrobel's reimplementation of Michalski's AQ
                    for structural descriptions
  CLUSTER         - Michalski and Stepp's Conceptual Clustering
  HEBBSIM         - Duwe & Grothaus connectionist association matrix
  SPROUTER        - Hayes Roth's Generalisation Algorithm


4. Ordering of files

Files  can  be  ordered either via  surface  or  electronic  mail,  or
accessed via anonymous ftp.

  Surface Mail    - Send a short notice to the address given at top of
                    this document.  Files will be distributed via  MS-
                    DOS formated 3.5 inch floppy, which should be send
                    with your request.

  E-Mail          - Send a short notice to the address given at top of
                    this document.

  FTP             - Files  are  accessible  via  anonymous  FTP   from
                    dione.rz.uni-osnabrueck.de (131.173.128.15)
                         userid:        FTP or ANONYMOUS
                         password:      your own userid
                         directory:     PUB/UNIX/MLP


5. Documentation notes

All  algorithms are written in Prolog with Edinburgh-syntax.  Most  of
the  time we use only Clocksin/Mellish or DEC-10  build-in  predicats.
However,  sometimes  it  can happen that  predicates  with  well-known
meaning  are  not build-in w.r.t.  Clocksin/Mellish  or  DEC-10  (e.g.
append,  member, bagof). Because they are so common, we rely that your
local  Prolog  system has access to their  definitions.  If  you  have
trouble with some paticular predicates in an algorithm send an  e-mail
to the address given at top of this document.  Either I will send  you
the predicate definition I use or I will fix the problem in the source
code as soon as possible.

If a particular algorithm only consists out of some predicats I try to
document every predicat (e.g.  EBG.PRO), otherwise I only document the
necessary  predicats  for  running the algorithm  and/or  the  special
changes I had to introduce (e.g. AQ1.PRO).

The  sign  '+'  in  front of an argument in  a  call  means  that  the
argument,  is  an  input  argument to  the  function,  which  must  be
instantiated.  A sign '-' in front of an argument,  means that this is
an output argument, which should not be instantiated. No sign in front
of an argument indicates that this argument works in both ways.

The  property  'backtrackable' indicates that the  predicate  is   re-
instantiated on backtracking. The property 'symmetric' means that this
predicat can also called with instantiated output arguments,  deliver-
ing the appropriate input arguments.


6. Notes on bug detection

The  algorithms  are more or less tested.  Sometimes bugs  can  occure
dependent  on our more or less extensive  testing.  Because  different
Prolog  dialects are mixed up on my micro testing is a difficult  task
for me.  If you find a 'new feature' which you didn't expected, let it
me  know,  so that others can benefit from your experience.  Send  bug
reports to the address given at top of this document.


7. Notes on software delivery

Because any library has to rely on authors, we encourage everybody who
has  implemented a machine learning algorithm to partitizipate in  the
extension of the library.

Software should be send on 3.5 inch floppies formated either for Atari
ST or MSDOS 3.X,  or by electronic mail to the address given at top of
this document.

For  the  purpose of a uniform documentation  and  easy  maintainance,
please  include  a  note with references about the  algorithm  and  if
possible  document  the  top-level  calls to  your  program  with  the
following form:

/**********************************************************/
/*                                                        */
/*  call        : predicate (+ARG1,-ARG2)                 */
/*                                                        */
/*  arguments   : ARG1 = is of type xyz                   */
/*                ARG2 = is something different in the    */
/*                       following form                   */
/*                                                        */
/*  side effects: which ever side effects the predicate   */
/*                produces                                */
/*                                                        */
/*  properties  : backtrackable, or whatever outstanding  */
/*                properties the predicate has            */
/*                                                        */
/*  references  : actual reference of the algorithm       */
/*                                                        */
/**********************************************************/
/* A short description of what the predicate does and how */
/* the input and output can be interpreted.               */
/**********************************************************/

[Solche messages verschicke ich am liebsten :-)  hwh]
************************************************************************