Free ai. software for linux

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.

AI::NNFlex is a base Perl class for implementing neural networks.

SYNOPSIS

use AI::NNFlex;

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

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

$network->init();

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

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

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

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

AI::NNFlex is a base class for constructing your own neural network modules. To implement a neural network, start with the documentation for AI::NNFlex::Backprop, included in this distribution

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::DecisionTree is Perl module for automatically Learns Decision Trees.

SYNOPSIS

use AI::DecisionTree;
my $dtree = new AI::DecisionTree;

# A set of training data for deciding whether to play tennis
$dtree->add_instance
(attributes => {outlook => sunny,
temperature => hot,
humidity => high},
result => no);

$dtree->add_instance
(attributes => {outlook => overcast,
temperature => hot,
humidity => normal},
result => yes);

... repeat for several more instances, then:
$dtree->train;

# Find results for unseen instances
my $result = $dtree->get_result
(attributes => {outlook => sunny,
temperature => hot,
humidity => normal});

The AI::DecisionTree module automatically creates so-called "decision trees" to explain a set of training data. A decision tree is a kind of categorizer that use a flowchart-like process for categorizing new instances. For instance, a learned decision tree might look like the following, which classifies for the concept "play tennis":

OUTLOOK
/ |
/ |
/ |
sunny/ overcast rainy
/ |
HUMIDITY | WIND
/ *no* /
/ /
high/ normal /
/ strong/ weak
*no* *yes* /
*no* *yes*

(This example, and the inspiration for the AI::DecisionTree module, come directly from Tom Mitchells excellent book "Machine Learning", available from McGraw Hill.)

A decision tree like this one can be learned from training data, and then applied to previously unseen data to obtain results that are consistent with the training data.

The usual goal of a decision tree is to somehow encapsulate the training data in the smallest possible tree. This is motivated by an "Occams Razor" philosophy, in which the simplest possible explanation for a set of phenomena should be preferred over other explanations. Also, small trees will make decisions faster than large trees, and they are much easier for a human to look at and understand. One of the biggest reasons for using a decision tree instead of many other machine learning techniques is that a decision tree is a much more scrutable decision maker than, say, a neural network.

The current implementation of this module uses an extremely simple method for creating the decision tree based on the training instances. It uses an Information Gain metric (based on expected reduction in entropy) to select the "most informative" attribute at each node in the tree. This is essentially the ID3 algorithm, developed by J. R. Quinlan in 1986. The idea is that the attribute with the highest Information Gain will (probably) be the best attribute to split the tree on at each point if were interested in making small trees.

Games::Euchre::AI is a Player API for Euchre card game.

This class implements a skeletal Euchre player programming interface. Subclasses can be created quite easily as interactive interfaces or AI computer players.
If you wish to write your own computer player, I recommend you start with Games::Euchre::AI::Simple. If you wish to write your own human interface, I recommend you start with Games::Euchre::AI::Human.

CLASS METHODS

new

Create and initialize a new Euchre AI. This object is implemented as an empty hash. Subclasses may wish to use this hash for state storage.

INSTANCE METHODS

Actions

The following methods are called in the course of the game where the AI (or human) has to make a decision. The state of the game is always passed in a hashreference. The following fields are always available:

name is the name of the current player. This is useful for output messages.
names is a hash relating player number to player name for all four players.
debug is a boolean indicating if we are debugging game or the AIs. Your AI may wish to provide verbose output if debugging is going on.

bid STATEHASH

Choose trump or pass. The relevent details of the current state of the game are provided in a hash reference. Here is an example of that data structure:

{
name => Player 1,
names => {1 => Player 1, 2 => P2, 3 => P3, 4 => Fred},
number => 1,
turnedUp => KH,
passes => 1,
ourScore => 2,
theirScore => 4,
winScore => 10,
hangdealer => false,
notrump => false,
hand => [JS, QH, 9S, KC, AD],
debug => false,
}

turnedUp is the suit and value of the card on the top of the blind. This will be undef on the second round of bidding.

passes says how many people have passed so far
hangdealer is a boolean saying whether the hang-the-dealer optional rule is in effect

notrump is a boolean saying whether the no trump optional rule is in effect
This function must return one of: H, D, C, S, N, HA, DA, CA, SA, NA, or undef
N means no trump, A means alone, undef means pass. Not all of these are legal at any given round! Use the isLegalBid() method below if you are unsure.

pickItUp STATEHASH

If this is called, you are the dealer and someone called trump. Choose which card from your hand to discard in exchange for the top card of the blind. The relevent details of the current state of the game are provided in a hash reference. Here is an example of that data structure:

{
name => Player 1,
names => {1 => Player 1, 2 => P2, 3 => P3, 4 => Fred},
number => 1,
turnedUp => KH,
trump => H,
bidder => 2,
weBid => false,
usAlone => false,
themAlone => false,
hand => [JS, QH, 9S, KC, AD],
debug => false,
}

This method should return the 0-based index of the card to trade for the turnedUp card. Namely, this in the index of the hand array for the card that you choose.

playCard STATEHASH

Choose which card from your hand to play on this trick. The relevent details of the current state of the game are provided in a hash reference. Here is an example of that data structure:

{
name => Player 1,
names => {1 => Player 1, 2 => P2, 3 => P3, 4 => Fred},
number => 1,
trump => H,
bidder => 2,
weBid => true,
usAlone => false,
themAlone => false,
trick => 2,
ourTricks => 0,
theirTricks => 1,
ourScore => 2,
theirScore => 4,
winScore => 10,
played => [10H, 9H, QC],
playedBy => [2, 3, 4, 1],
hand => [JH, AH, AS, KS],
debug => false,
}

playedBy is an arrayref of numbers of the players in the order they will play. Without this, the alone possibility makes it hard to tell who played what.

Any needed information not stored here (like who was the dealer, what was the turn-up card, what happened in the first trick) is YOUR responsibility to collect and store in your instance.

This method should return the 0-based index of the card to play. Namely, this in the index of the hand array for the card that you choose.

MaitreTarot project is a French Tarot game.
It is a game like Freecell or poker, and has nothing to do with astrology. It has a server and various client software.
Main features:
- A server, that knows the rules, that gives the cards to the clients, that counts the points, and everything else that a server should do.
- Clients. The main idea is to have differents clients. Some would be clients for human players, with a GUI (gtk+, qt, web, ncurses, win32...). And some would be AI. That would allow users to play with AI, and even AI tournaments could be played in order to know the best AI!
Enhancements:
- minor changes in mt_gtk_client
- libmaitretarot is split into libmaitretarot and libmt_client