Free ai. software for linux

Rhino is an Othello/reversi game.
The goad is to have a very strong AI and useful as a learning tool for those who want to master the game.
What distinguish GRhino from most other Othello games is that GRhino will be targeted for experienced Othello players. Strong AI is the main focus with some additional good, useful features (like an endgame solver) is planned. The ultimate target strength of the AI is that it should be able to beat the best human player at the highest difficulty level. Beating Logistello (the strongest program available) is not in the plan.
Some important AI infrastructure has been finished. Pattern evaluator and open book are mostly done but still requires some further optimization and data file compression.
Multi prob-cut to speedup the AI is still missing so it still has a limit on its game strength but this mostly affects playing against other strong AI out there. The main focus for current development is about user interface and features. Currently finished parts include
- End game search. It can now solve the exact score (in about 20 sec on P-133) at around 15 empties and Win-Loss-Draw at a slightly higher number of empties.
- Move ordering.
- Start game from known openings.
- Display opening name.
- A decent pattern-based evaluation with parity knowledge.
- A decent open book with opening variations allowed.
- Browse IOS and GGS format game file.

Mind AI project is an artificial mind based on some advanced concepts:
- machine learning
- representation
- meta representation of concepts
- concept reflection
- reification
- denotation
Interaction with the AI is done via IRC.
Enhancements:
- geo: start some geo-location development ; play with AddressInfo class and think about LocationProvider implementation
- irc: add support for PING / PONG mechanism
- add support for *help command

AI::NeuralNet::Kohonen is a Perl module with Kohonens Self-organising Maps.

SYNOPSIS

$_ = AI::NeuralNet::Kohonen->new(
map_dim_x => 39,
map_dim_y => 19,
epochs => 100,
table =>
"3
1 0 0 red
0 1 0 yellow
0 0 1 blue
0 1 1 cyan
1 1 0 yellow
1 .5 0 orange
1 .5 1 pink"
);

$_->train;
$_->save_file(mydata.txt);
exit;

An illustrative implimentation of Kohonens Self-organising Feature Maps (SOMs) in Perl. Its not fast - its illustrative. In fact, its slow: but it is illustrative....

AI::FuzzyLogic is a Perl module for Fuzzy Set Operations and Tools.

SYNOPSIS

use AI::FuzzyLogic;

$i = new AI::FuzzyLogic $unittype, @numbers; # new set with one subset
$i = new AI::FuzzyLogic age, 0, 0.1, 0.2, 0.1, 0; # same thing

$i = new AI::FuzzyLogic $subset1, $subset2, $subset3; # new set with several subsets

# another syntax for building a set with several subsets:
$i = AI::FuzzyLogic->new(
AI::FuzzyLogic->new(distance, 0.0, 0.1, 0.1, 0.5, 0.8, 0.6, 0.3, 0.0),
AI::FuzzyLogic->new(time, 0.3, 0.3, 0.1, 0.1, 0.1, 0.2, 0.3, 0.3),
AI::FuzzyLogic->new(heat, 0.0, 0.1, 0.1, 0.2, 0.2, 0.3, 0.3, 0.2),
);

# constructors for explicit combinational behavior:
$i = new AI::FuzzyLogic::Correlator speed, 0.1, 0.3, 0.2, 0.1, 0.1;
$i = new AI::FuzzyLogic::Permutator speed, 0.1, 0.3, 0.2, 0.1, 0.1;
$i = new AI::FuzzyLogic::Discriminator speed, 0.1, 0.3, 0.2, 0.1, 0.1;
$i = new AI::FuzzyLogic::Abstractor speed, 0.1, 0.3, 0.2, 0.1, 0.1;

# change combinational behavior:
$set->as_correlator(); # operations work on matching subsets of same type
$set->as_permutator(); # operations work across all subsets of each set
$set->as_discriminator(); # operations best matching subset from right for each on left
$set->as_abstractor(); # operations return one set with one subset summerizing fit

$i->add_subsets($j); # combine subsets or other sets in

abs($i) # defuzzify to integer (centroid - curve middle, x axis)
0+$i # defuzzify to integer (mean - average curve height, y axis)

$a & $b # intersection of sets
$a | $b # union of sets
$i++ # normalize curve to 1.0
$i-- # stretch curve to edges
~$i # negate set
$i ** 0.5 # dialation
"$i" # convert subsets to ASCII graphs

$a + $b # sum sets
$a - $b # subtract sets
$a * $b # multiply sets - useful for sensitivity control
$a / $b # divide sets - useful for sensitivity control

$h->larger($a) # boolean: does $h completely encompass $a?

$a ^ $b # xor: same as ~($a | $b)
$a < $b # compare volume: is $a smaller?
$a > $b # compare volume: is $a larger?

@sets = $a->unwrap(); # get subsets as list of AI::FuzzyLogic::Subset objects
@sets = $a->query_type(type); # get subsets of type type as a list of AI::FuzzyLogic::Subset objects
$a->change_type(fromtype, to); # change type of subsets of type fromtype to to

Performs all basic operations on Fuzzy Sets. Use English-like, intentionally vague objects representing concepts with which to make inferences. The inferences might be approximate reasoning about precise knowledge, or precise reasoning about approximate knowledge. This vagueness allows the capture and application of human expert knowledge.

Overloads Perl operators to perform operations on Fuzzy Sets.

AI::NNFlex::Backprop project is a fast, pure perl backprop Neural Net simulator.

SYNOPSIS

use AI::NNFlex::Backprop;

my $network = AI::NNFlex::Backprop->new(config parameter=>value);

$network->add_layer(nodes=>x,activationfunction=>function);

$network->init();



use AI::NNFlex::Dataset;

my $dataset = AI::NNFlex::Dataset->new([
[INPUTARRAY],[TARGETOUTPUT],
[INPUTARRAY],[TARGETOUTPUT]]);

my $sqrError = 10;

while ($sqrError >0.01)

{

$sqrError = $dataset->learn($network);

}

$network->lesion({nodes=>PROBABILITY,connections=>PROBABILITY});

$network->dump_state(filename=>badgers.wts);

$network->load_state(filename=>badgers.wts);

my $outputsRef = $dataset->run($network);

my $outputsRef = $network->output(layer=>2,round=>1);

AI::NNFlex::Backprop is a class to generate feedforward, backpropagation neural nets. It inherits various constructs from AI::NNFlex & AI::NNFlex::Feedforward, but is documented here as a standalone.
The code should be simple enough to use for teaching purposes, but a simpler implementation of a simple backprop network is included in the example file bp.pl. This is derived from Phil Brierleys freely available java code at www.philbrierley.com.

AI::NNFlex::Backprop leans towards teaching NN and cognitive modelling applications. Future modules are likely to include more biologically plausible nets like DeVries & Principes Gamma model.

Full documentation for AI::NNFlex::Dataset can be found in the modules own perldoc. Its documented here for convenience only.

AI::NeuralNet::BackProp is a simple back-prop neural net that uses Deltas and Hebbs rule.

SYNOPSIS

use AI::NeuralNet::BackProp;
# Create a new network with 1 layer, 5 inputs, and 5 outputs.
my $net = new AI::NeuralNet::BackProp(1,5,5);

# Add a small amount of randomness to the network
$net->random(0.001);

# Demonstrate a simple learn() call
my @inputs = ( 0,0,1,1,1 );
my @ouputs = ( 1,0,1,0,1 );

print $net->learn(@inputs, @outputs),"n";

# Create a data set to learn
my @set = (
[ 2,2,3,4,1 ], [ 1,1,1,1,1 ],
[ 1,1,1,1,1 ], [ 0,0,0,0,0 ],
[ 1,1,1,0,0 ], [ 0,0,0,1,1 ]
);

# Demo learn_set()
my $f = $net->learn_set(@set);
print "Forgetfulness: $f unitn";

# Crunch a bunch of strings and return array refs
my $phrase1 = $net->crunch("I love neural networks!");
my $phrase2 = $net->crunch("Jay Lenno is wierd.");
my $phrase3 = $net->crunch("The rain in spain...");
my $phrase4 = $net->crunch("Tired of word crunching yet?");

# Make a data set from the array refs
my @phrases = (
$phrase1, $phrase2,
$phrase3, $phrase4
);

# Learn the data set
$net->learn_set(@phrases);

# Run a test phrase through the network
my $test_phrase = $net->crunch("I love neural networking!");
my $result = $net->run($test_phrase);

# Get this, it prints "Jay Leno is networking!" ... LOL!
print $net->uncrunch($result),"n";

AI::NeuralNet::BackProp is the flagship package for this file. It implements a nerual network similar to a feed-foward, back-propagtion network; learning via a mix of a generalization of the Delta rule and a disection of Hebbs rule. The actual neruons of the network are implemented via the AI::NeuralNet::BackProp::neuron package

AI::ExpertSystem::Simple is a simple expert system shell.

SYNOPSIS

This class implements a simple expert system shell that reads the rules from an XML knowledge base and questions the user as it attempts to arrive at a conclusion.

This class is where all the work is being done and the other three classes are only there for support. At present there is little you can do with it other than run it. Future version will make subclassing of this class feasable and features like logging will be introduced.

To see how to use this class there is a simple shell in the bin directory which allows you to consult the example knowledge bases and more extensive documemtation in the docs directory.

AI::Menu is a Perl object that generates Tree::Nary objects from directed graphs or a description of the function set.

The algorithm is not very efficient (approximately O(F^6), F being the number of functions). It is also not quite as intelligent as it should be. You should cache the results instead of repeatedly calculating them.

As the algorithm is optimized or more efficient algorithms are found, they will be incorporated. The interface for generating the trees should not change too much. The resulting object might become a Tree::Nary object encased in an AI::Menu object.

SYNOPSIS

use AI::Menu;

my $factory = new AI::Menu::Factory;

my $menu = $factory->generate($hash_of_functions);
my $menu = $factory->generate($hash_of_functions, $hash_of_categories);
my $menu = $factory->generate($graph);

METHODS

All of the following methods (except generate) are available in the new function when creating the AI::Menu::Factory object.

generate

This function does some housekeeping before calling a configurable module to generate the tree.

If called with a single hash reference, the hash is assumed to be a list of functions mapping to array references containing a list of categories. It is further assumed that the sets of function names and category names are disjoint. A closure is created for the leaf_q function which returns true if its argument is a key in the hash reference. The complete graph is created from this single hash reference: if a category can reach another category through a function, then an edge is inserted between the two categories. This edge is bidirectional.

If called with two hash references, the first hash is treated as before, but the second hash reference is considered a mapping of categories to categories. This second hash is used instead of automatically generating the information from the first hash.

If called with a single object that is not a hash reference, then the argument is considered a graph object (usually of Graph::Directed). The leaf_q function will need to be defined.

leaf_q

This function returns true if the argument represents a function (leaf in the graph). It returns false if the argument represents a category. This may be set either when the AI::Menu::Factory object is created or through a method call. The method call with no argument returns the current function.

maker

This is the package used to create the menu from the graph. The following call is made:

my $menu = $self -> {maker} -> new(
width => $self->{width},
weight_f => $self -> {weight_f},
leaf_q => $leafq,
);

return $menu -> generate_tree($g, $optscore);

The $optscore value is the score for the optimum tree. Once a tree is found with this score, searching should stop.

new

Creates an AI::Menu::Factory object. Optional arguments are key/value pairs taken from this list of methods except for generate and new.

weight_f

This function is used to calculate the edge weights in the graph. It is called with four arguments: the object generating the tree, the graph object, the originating vertex, the destination vertex. The function should return undef for an infinite weight.

width

This is the desired number of children per node. The optimal number (and default) is three.