AIMA Code

AIMA-Java 1.6.0-Chp5-Rewrite

2012-01-08T16:03:00.000-08:00

Ruediger has rewritten all of the logic from Chapter 5: Adversarial Search. In addition, he has added a new GUI demo application - Connect 4, in order to highlight the algorithms usage in larger search spaces. This can be run from the demo page:

http://aima-java.googlecode.com/svn/trunk/aima-all/release/aima3ejavademos.html

Enjoy!

Ciaran

AIMA-Java 1.5.2-Chp17n21-Rewrite

2011-09-16T08:09:00.000-07:00

All of the algorithms from Chapters 17 and 21 have been rewritten, this includes:

17.4 Value-Iteration
17.7 Policy-Iteration
21.2 Passive-ADP-Agent
21.4 Passive-TD-Agent
21.8 Q-Learning-Agent

In addition:

Rewrote Cell World Environment (environment.cellworld) to be independent of use.
Re-organized probability.hmm package.
Minor optimization to FrequencyCounter implementation.
Documentation clean up.

Enjoy!

Ciaran

AIMA-Java 1.5.1-Chp15-Rewrite

2011-07-31T15:54:00.000-07:00

All of the algorithms from Chapter 15 have been rewritten:

15.4 Forward-Backward (3 implementations provided)
15.6 Fixed-Lag-Smoothing
15.17 Particle-Filtering

Added an Iterator interface and supporting methods to CategoricalDistribution and Factor. ProbabilityTable.Iterator removed getPostIterateValue() method from API due to not being general. Fixed Issue 63 - all compilation warnings have been resolved or suppressed where appropriate for now. Documentation clean up.

Enjoy!

Ciaran

Michael Stampone officially Joins the Team

2011-07-11T09:56:00.000-07:00

Michael has been doing great work updating the project's Javadoc and plans to do some games development (chess and checkers) possibly using JOGL to demonstrate some of the core algorithms. He now has commit privileges on the project.

Best

Ciaran

AIMA-Java 1.5.0-Chp13-and-14-Rewrite

2011-07-03T10:07:00.000-07:00

This is the official release of the rewrite of the probability logic from Chapters 13 and 14 of AIMA3e. This includes rewrites for the following algorithms:

14.9 Enumeration-Ask
14.13 Prior-Sample
14.14 Rejection-Sampling
14.15 Likelihood-Weighting
14.16 GIBBS-Ask

as well as the addition of:

14.11 Elimination-Ask

A fix for Issue 66 is also included as well as some minor refactoring and documentation cleanup.

Enjoy!

Ciaran

Demo Applications now run from Google Code

2011-06-24T08:10:00.000-07:00

Read a couple of articles related to sending out content from a Subversion repository:

http://code.google.com/p/rdv/wiki/JavaWebStart
http://stuffthathappens.com/blog/2007/11/09/howto-publish-javadoc-on-google-code/

and realized I needed to update the svn:mime-type on the relevant .html, .css and .jnlp files to their correct values. All appears to be working now so to get to the main demo page from now on just go to:

http://aima-java.googlecode.com/svn/trunk/aima-all/release/aima3ejavademos.html

Enjoy!
Ciaran

Rewrite of Chapters 13 and 14 available

2011-06-22T20:44:00.000-07:00

An extensive rewrite of the probability logic from Chapters 13 and 14 has been committed to the bleeding edge code base. This includes the addition of the EliminationAsk algorithm.

Enjoy!

Ciaran

AIMA-Java 1.4.1-Minor Fixes

2011-03-20T14:08:00.000-07:00

This is a minor patch release to 1.4.0 including fixes to the probability and logic implementations in aima-core and a minor tweak to the aimax-osm project.

Enjoy!

Ciaran

AIMA-Java 1.4.0-OSM Redesign

2010-12-19T10:17:00.001-08:00

This includes a redesign of the aimax-osm project and compilations and unit fixes for the UBUNTU platform.

Enjoy!

Ciaran

AIMA-Java 1.3.2-Online+CSP+GUI-Improvements Released

2010-11-05T09:35:00.001-07:00

This is primarily a clean up release, with changes made primarily to the existing Online, CSP and GUI components.

Enjoy!

Ciaran

AIMA-Java 1.3.1-CSP+PathCost-Fixes released

2010-10-02T11:03:00.000-07:00

This is primarily a bug fix release which resolves an issue with Backtracking CSP search and the calculation of path costs when running breadth first search.

Enjoy

Ciaran

Upgrading Ruediger ;-)

2010-08-23T06:56:00.000-07:00

Ruediger Lunde has been promoted to project owner due to his significant work on the project (solely responsible for aimax-osm extension project and nearly the totality of the aima-gui project as well as many contributions and improvements to aima-core).

Release 1.3.0 - CSP Refactored AC-3 Added and 4 new GUIs

2010-08-22T15:37:00.000-07:00

Ruediger has been super busy again improving the implementation of the Constraint Satisfaction algorithms, adding the AC-3 algorithm as well as adding four new demonstration GUIs:

Eight Puzzle
N-Queens Problem
Tic-Tac-Toe
Map Coloring Problem

Release of 1.2.2-AIMA3e AIMAX-OSM Many Improvements

2010-06-19T11:28:00.000-07:00

Ruediger has been busy improving the AIMAX-OSM applications with the following improvements:

1. Storage efficency of map representation improved.
2. Rendering speed and quality improved.
3. osm.gz2 file format support added.
4. Reader extended to read parts of a map, specified by bounding box or attribute filter.
5. Writer for writing maps to file added.
6. Slow zoom (activated with ) added.
7. Scale factor replaced by true scale.
8. Mark creation at specified GPS positions added, info dialog extended by node position.

AIMA Java 1.2.1 Released - GUIs available via Java Web Start

2010-03-15T17:27:00.000-07:00

This release includes several enhancements to the aima-gui and aimax-osm GUI applications (thanks Ruediger). In particular, the AimaDemoApp was updated to include all the command line demos (their output is redirected to a text area widget when run). In addition, we have set up a page for running each of the GUIs from your browser using Java Web Start. This may be linked to from the projects main page:

http://code.google.com/p/aima-java/

'Click here for AIMA3e Java Demo Applications'

or directly via:

http://www.ai.sri.com/~oreilly/aima3ejava/aima3ejavademos.html

Enjoy!

AIMA Java 1.1.0 Released

2010-02-06T18:07:00.000-08:00

This is our second release based on the 3rd edition of AIMA. This includes a new extension project, the Open Street Map (OSM) library, which has been kindly provided by Ruediger Lunde. This takes advantage of several of the algorithms and utilities from the aima-core and aima-gui projects. Please note that this project is under a different license. Enjoy!

Ciaran

AIMA Java 1.0.0 Released

2009-12-10T17:23:00.001-08:00

This is our first release based on the 3rd Edition of Artificial Intelligence a Modern Approach, see - http://code.google.com/p/aima-java/wiki/ReadMe for details of what is included/changed.

Enjoy!

Ciaran

AIMA Java 0.95 Released

2009-10-03T18:07:00.000-07:00

This is our first release containing GUIs (thanks to Ruediger Lunde) see:

- aima.gui.applications.VacuumAppDemo
Provides a demo of the different agents described in Chapter 2 and 3
for tackling the Vacuum World.

- aima.gui.applications.search.map.RoutePlanningAgentAppDemo
Provides a demo of the different agents/search algorithms described
in Chapters 3 and 4, for tackling route planning tasks within
simplified Map environments.

- aima.gui.framework.SimpleAgentAppDemo
Provides a basic example of how to create your own Agent based
demonstrations based on the provided framework.

This will also be our last full release based on the 2nd edition of AIMA.
We are currently in the planning phases to re-organize this project based on the 3rd edition of AIMA, which should be available soon.

Enjoy!

Upgrading Ciaran ;-)

2009-07-21T00:43:00.000-07:00

Ciaran O'Reilly is now joint owner of this project, along with me (Ravi). He has done awesome work in the logic chapters code (and any bug reports should be sent to him ;-). Just kidding, if I get any bug reports for the logic code I can forward to him).

We'll be starting work on the code for AIMA 3d edition soon.

AIMA JAVA v0.94 released

2009-05-30T08:57:00.000-07:00

This is a patch release for the FOL Logic and includes the following fixes:

- Fixed subtle defect in Model Elimination inference algorithm, which caused it to miss portions of the search space.

- Improved the performance of both theorem provers, in particular added support for forward and backward subsumption elimination, which improves significantly the performance and use of the OTTER Like theorem prover.

- Fixed defect in cascade occurs check in unifier logic.

Complete implementation of Chapter 9 Available

2008-12-10T18:24:00.000-08:00

Ok,

It's been a while, but finally after much grinding away, a complete implementation of all of the main First Order Logic concepts from Chapter 9 has now been added to the bleeding edge code base. In addition, for giggles :-), I've added an inference algorithm based on model elimination. You can run the FOLDemo:

aima.logic.fol.demos.FolDemo

to get an overview of the different capabilities. I ended up taking a class on Computational Logic (see: http://logic.stanford.edu/classes/cs157/2008/cs157.html) in order to get my head around several of the nuances involved in implementing general purpose theorem provers. Highly recommended for those so inclined. I've tried my best, 100+ test cases, to make the resolution based and model elimination implementations sound and complete, as well as reasonably efficient but no guarantees :-) Enjoy!

Implementation of LRTA*-Agent (Fig. 4.23) available

2008-02-23T11:17:00.000-08:00

The implementation for this algorithm can be found in:
aima.search.online.LRTAStarAgent
with a test case available in:
aima.test.search.online.LRTAStarAgentTest

enoy!

AIMA JAVA v0.92 released

2007-12-25T12:30:00.000-08:00

This release has a rewrite of the Neural Network code. The old code didn't do pre processing of data and so the networks would get saturated for some data sets. The new code normalizes the data sets and so doesn't have this problem.

The release also includes an implementation of Online DFS (Thanks Ciaran!). Carl Anderson, Senior Scientist at ArchimedesModel.com requested that heuristic functions return doubles instead of int. This is an excellent idea so that's done as well.

The next release scheduled for 28th Feb, will have code for planning (chapters 11 and 12 + bits of chapter 9) + whatever else we feel like working on!

Implementation of Online DFS Agent (Fig. 4.20) available

2007-11-18T14:04:00.000-08:00

Been a while, was home back in Ireland visiting family and friends and started a new job, so have had a little less time available to hack away at this stuff. The implementation for this algorithm can be found in:
aima.search.online.OnlineDFSAgent
with a test case available in:
aima.test.search.online.OnlineDFSAgentTest
Enjoy!

AIMA JAVA 0.91 released

2007-10-18T23:43:00.000-07:00

Well, it was released on Oct 1, 2007 but I forgot to announce it here. This release adds all of Ciaran's work on the search algorithms plus the usual bug fixes.

The next release is scheduled for Nov 15, 2007.

Genetic-Algorithm implementation added

2007-09-07T17:25:00.000-07:00

An implementation of the algorithm described in Figure 4.17 page 119 is now available. The NQueensDemo has been updated to include an example of calling this algorithm. Of interest is the number of iterations/time it takes, on average with respect to the size of the search space, compared to the other algorithms to converge on a goal.

Recursive-Best-First-Search available

2007-08-28T14:59:00.000-07:00

Just finished an implementation of the Recursive-Best-First-Search from Figure 4.5 page 102 of AIMA. The implementation may be found in aima.search.informed.RecursiveBestFirstSearch along with an associated test case in aima.test.search.searches.RecursiveBestFirstSearchTest, which creates a test that mimics Figure 4.6 from page 103. This has also been added to the MapDemo. I think a Genetic Algorithm implementation is up next :-)

Implementation of Bidirectional search available

2007-08-23T15:32:00.000-07:00

After a week of crashed machines and painful recovery/upgrading efforts, I finally got around to implementing a version of the Bidrectional search described on page 79 of the text book. This can be found in aima.search.uninformed.BidirectionalSearch. A fairly comprehensive test driver for this can be found in aima.test.search.searches.BidirectionalSearchTest as the implementation turned out to be a little trickier/subtler than originally anticipated.

Chp 3 Additions to Bleeding Edge Code

2007-08-19T10:53:00.000-07:00

Added implementations for:

Fig 3.1, pg 61 Simple-Problem-Solving-Agent: aima.search.framework.SimpleProblemSolvingAgent
Fig 3.2, pg 63 Romania: aima.search.map.SimplifiedRoadMapOfPartOfRomania

In addition added an implementation of the
Uniform-cost search from page 75.

A demo of these can be seen in:
aima.search.demos.MapDemo
which uses all the existing uninformed search algorithms. Currently considering writing an implementation of the BidirectionalSearch as well in order to round out all the searches discussed in Chapter 3 - fun fun :-)

Dr Ciaran O Reilly joins the Aima Java Project

2007-08-12T23:21:00.000-07:00

Dr Ciaran (pronounced Keeraan) O' Reilly, a researcher in AI from the San Fransisco Bay Area, has joined the AIMA Java project.
Having another contributor to the code base is awesome! We are still working out the fiddly details like how to ensure the formatting conventions are shared etc, but Ciaran's code has been checked into the codebase and he has commit rights (though he is still having problems with the svn server at Google code).

Parsing changes for Version 1.0

2007-07-10T02:03:00.000-07:00

After a small hiatus, I Started working on version 1.0. The focus will be on implementing the "logic arc" from chapters 8 thru 19. The propositional logic part has been done but first order logic and planning is very sparse.

One of the problems of working with logic in java is that one ends up writing custom parsers. I don't want to use parser generators (like jlex/cup), because that would increase the number of jars/libraries that users need to download. Thus the recursive descent parsers in aima java.

Coding the lexer and parser and associated visitors is very tedious and I was a little desperate to remove the tedium. One approach is to write an SExp parser that takes care of generic sexp parsing and another need specific parser that parses the resulting sexps into the required dtata structures. I've prototyped this and it does seem to work.

I am still stuck on visitors though. Most tree walking needs double despatch and "visitor" seems to be the only way to do this in Java. The code is f_ugly though.

Hosted on Google Project Hosting

2007-06-15T15:13:00.000-07:00

Dr Norvig has moved the repositories of the Java and Python code to Google Project Hosting.

Version 0.9 of AIMA -Java is now official ,

[AIMA JAVA Pre Final] Implemented Q Learning Agent

2007-05-13T06:58:00.000-07:00

This completes Chapter 21

[AIMA JAVA Pre Final] Implemented PassiveADPAgent And PassiveTDAgent

2007-05-12T22:23:00.000-07:00

The Passive ADP Agent converges much faster than the PassiveTDAgent, which is as it should be.
The Alpha symbol was a bit confusing till I recognized it was the probability normalizing constant!(I mistook it for a learning constant like the ones in neural networks).

Now onto Q Learning!

[AIMA JAVA Pre Final] Implemented Policy Iteration

2007-05-09T01:43:00.000-07:00

This completes Chapter 17

[AIMA JAVA Pre Final] Implemented Value Iteration

2007-05-04T08:42:00.000-07:00

The code is now generic enough to handle any M by N environment with x ( >= 0 ) blocked squares. The MDP is derived out of the world structure. A further refinement might be to implement some kind of text file reader so that folks could design new worlds. I'll wait and see if there is enough demand for something like this.

AIMA JAVA Pre Final - Implemented CellWorld

2007-04-29T11:14:00.000-07:00

checked into the google code repo.
Number of tests = 399.

AIMA JAVA Pre Final - Implemented Particle Filtering

2007-03-25T00:01:00.000-07:00

This completes Chapter 15

AIMA JAVA Pre Final - (HMM) Fixed Lag Smoothing Implemented

2007-03-23T03:56:00.000-07:00

I've duplicated the algorithm in the text (fig 15.6 in my edition), but this (algorithm, as published) is almost certainly wrong. The forward operation uses the latest (the t-d th would have made more sense) perception. This doesn't make too much sense.
The values don't match up with those generated by the foreward backward implementation (which is almost certainly working correctly).

Need to get the algorithm clarified by Dr N. Incredibly enough, there aren't too many resources online about this particular (variant of the) algorithm .

AIMA JAVA Pre Final - (HMM) Forward Backward Implemented

2007-03-13T08:05:00.000-07:00

nice snippet of code. very powerful algorithm

AIMA JAVA Pre Final - Present Status

2007-03-12T07:52:00.000-07:00

Working on Chapter 15.

Implemented an HMM with predict, update and forward.
The code for this (after extensive refactoring) is looking good.

I used an example from Probabilistic Robotics as an additional requirement for the HMM code, i.e, enable the HMM implementation to model a robot with uncertain sensors and stochastic actions. This has worked out well, as an HMM modelling a robot has to make provision for robot actions.

The example in AIMA models a passive observer trying to estimate the probability of rain from seeing whether his superior carries an umbrella or not. Unlike the robot, he has no action he can take that modifies the environment.

The present implementation models both these situations as can be seen from the unit test.

I've also implemented the code for single step smoothing (section 15.2 page 545 in my edition).

AIMA JAVA Pre Final - The Plan

2007-03-12T07:32:00.000-07:00

I expect to post the pre final version of the AIMA java code to Dr Norvig at the end of this april/beginning of May.

This release will contain the code for Chapters 15(Probabilistic Reasoning),16 (Simple Decisions), 17(Complex Decisions) and 21 (Reinforcement Learning). I also need to fill in a few gaps in the code list. Plus bug fixes.

If anyone is having problems with the game playing code, do get the latest code . For some reason, the code at the site doesn't match with the code base though this code was written well before the last release.

The next release (AIMA Java Final) will focus on implementing the code for the "logic arc" ie chapters 9,10,11,12 and 19. The code for prepositional logic is already in place and has been extensively field tested, but I am not very happy about the FOL code. This will probably get rewritten.