I thought about an AI library for python. This is the possible
structure I came up with. Are there any thoughts about it?
ailib/
search.py
class State:
"represents an immutable state of a problem"
def __str__(self):
pass
def __hash__(self):
pass
class StateSpace:
"represents a traversable collection of states"
def start(self):
"returns a list of initial states"
pass
def follow(self, state).
"returns a list of states that follow after state"
pass
def search(self, order=none):
"""returns an iterator over all states according to
order
order can be a constant (depth, breadth, incdepth) or
a
heuristic. If none some default search will be
used."""
pass
def __iter__(self):
return self.search()
class Heuristic:
def follow(self, state):
"returns a list of states probably closer to the
solution than s
pass
class Graph(StateSpace):
def __init__(self, paths)
"paths is a set of tuples (nodeFrom, nodeTo, weight)"
pass
def a-star(self, nodeFrom, nodeTo):
"""searches the shortest path (minimal weight) from
nodeFrom to nodeTo."""
pass
plan.py
class State(search.State):
"represents a state of the world that can be changed
through action.
pass
class Agent(search.StateSpace):
"""For any given state an Agent has a set of possible
actions
that transform the initial state into a subsequent
state."""
def perceive(self):
"returns the state of the world the agent perceives to
be in."
pass
def actions(self, state):
"returns an iterator over actions available in the
given state."
pass
def __iter__(self):
return self.actions(self.perceive())
def plan(self, state, currentState=none):
"""returns a sequence of actions that are supposed to
transform the currently perceived state of the world
into the desired state."""
if currentState==none:
currentState = self.perceive()
else:
pass
logic.py
class Symbol:
"a Symbol that can be bound to a value or unbound."
def bound(self):
"returns true if the symbol is bound."
def value(self):
"if bound returns the value."
class Function:
"transforms a list of symbols into another symbol."
def __init__(self, *symbols):
self.symbols = symbols
def __call__(self):
"returns some symbol."
pass
class Predicate:
"either is or is not valid for a given list of symbols"
def __init__(self, *symbols):
self.symbols = symbols
def __call__(self):
"returns true or false"
pass
class Junctor:
"""a relation between predicates deriving a truth value
from the
truth values of the predicates"""
def __init__(self, *predicates):
self.predicates = predicates
def __call__(self):
"returns some truth value"
pass
class Quantifier:
"somehow binds symbols."
pass
class Clause:
"A quantified junctor."
pass
class Axioms:
"A list of clauses"
def consistent(self):
"returns true if the list of axioms is consistent"
pass
def valid(self, clause, bind=true):
"""returns true if the clause is consistent with the
set of axio
If bind is true, any unbound symbol will be bound to a
value if
pass
statistics.py
class Entity:
"bearer of statistically relevant features."
pass
class Set:
"set of entities. defines usual statistical functions"
def __iter__(self):
"iterate over all entities."
def avg(self, feature):
"returns the average of the given feature of all
entities."
pass
# likewise other functions
def entropy(self, a, b):
"returns the level of randomnes (0..1) between the
given feature
pass
def correlates(self, a, b, e=0.5):
return self.entropy(a, b) < e
def mine(self):
"returns the tuple of features with the least
entropy."
game.py
class Game:
"""Basically extends planning with multiple agents who
take turns."""
pass
language.py
class Morphology:
"word recognition."
def lookup(self, word, guess=false):
"""returns a list of dictionaries of features for the
given word
If guess is true, tries to guess features if
unsure."""
class Rule:
"a Rule of the language like S -> np, vp. Can have a
probability."
pass
class Language:
"A set of rules."
def parse(self, sentence):
"""tries to parse the sentence according to the rules.
returns an iterator over possible parse trees which
are
tuples (category, content). If rules have probability
the iterator returns tuples (parse tree, probability)
in
the order of descending probability."""
pass
def semantics(self, parse):
"returns a semantic interpretation (logic.Clause) of a
given par
pass
class Text:
"A list of sentences who stand in rethorical relations to
each other
pass
class Discourse:
"""A list of texts as utterances of given speakers
(plan.Agent)
which are each supposed to further the established
knowledge about
the discourse universe."""
pass
neural.py
class Neuron:
"Turns a vector of input to an output."
def __init__(self, weights):
self.weights = weights
def __call__(self, input):
"scalar product of input and weights"
pass
class NeuralNetwork:
def __init__(self, input, inter, output):
"""specify size of input matrix, intermediate matrix
and output
neurons will be generated."""
pass
def train(self, input, output):
"train network to produce output from input."
pass
def __call__(self, input):
"produces output matrix from input."
--
http://mail.python.org/mailman/listinfo/python-list
