just some thoughts on "proof by contradiction" introduced on page 250 used on
page 254, 7th line from the end `...we wish to prove α which is,say,¬P12`

according to proof by contradiction, it is : KB ∧ ¬ α,

but in the example, it is α= ¬P12

So ¬ α is: ¬(¬P12),  will become just P12 and so it is reflected in Figure
7.13

[ Apologies if you receive multiple copies of this announcement. ]

Hello:

Concordia University is organizing C3S2E'11, the Fourth International C*
Conference on Computer Science and Software Engineering, in May 2011.

With so many questionable academic meetings and their CFPs which we get
everyday, direct emailing has become a nuisance; hence, we need to depend
on the old reliable grapevine approach. We would, consequently, appreciate
if you would bring the CFP for this meeting to the attention of your
colleagues and students.

We plan also to have a number of workshops. If you would like to organize
one, please contact one of the program chairs. As a general rule, you
would be responsible for the CFP and review and acceptance of papers for
the workshop. The Admin for ConfSys would set up the system for the
workshop. The accepted papers for the workshop would be scheduled during
the workshop slot and the papers would be published with the C3S2E'11
proceedings published by ACM.

Since ConfSys review is triple blind: committee members of the workshop
could also submit paper.

In the demo/poster session, graduate students are invited to compete
by presenting their work in progress either as a poster or a demo.
The students have a chance to orally present their work and answer
questions. The length of a poster paper and demo proposal for review purposes
would be 5-7 pages. However, the final version is limited to 3
pages in the ACM proceedings format. All submissions would be reviewed
and the student authors of at most 10 highest scoring submissions
would have their registration fees waived. In case there are multiple
student authors only one student per such poster/demo paper is eligible for
the registration fee waiver. The student's adviser could be a co:author
of a poster paper or demo proposal; however, if the poster paper/demo
is accepted, the student is required to register and participate.
Poster papers and demo papers would be published as part of the C3S2E
proceedings. The demo and poster submissions are due in March.

Conference URLs (CFP):
   http://confsys.encs.concordia.ca/c3s2e/c3s2e-11

Submission system:
   https://confsys.encs.concordia.ca/ConfSys/

Contact:
   admin@...

Program committee:
   http://confsys.encs.concordia.ca/c3s2e/c3s2e-11/ProgramCmt-C3S2E11.html

Previous publications:
   (2010) http://portal.acm.org/citation.cfm?id=1822327
   (2009) http://portal.acm.org/citation.cfm?id=1557626
   (2008) http://portal.acm.org/citation.cfm?id=1370256


CFP details:
============

Call for Regular, Workshops and Position papers; posters and demo
-----------------------------------------------------------------

C3S2E'11 is the fourth in a revived series of international conferences to
address the need of the academic community in computing science and
software engineering. The objective of C3S2E is to meet annually to
exchange ideas on the continuing need to address the new challenges both
from the theoretical as well as application aspects of computing and
engineering of software systems. C3S2E encourages the participation of
practitioners from governmental and non-governmental agencies, industries,
and academia.

C3S2E invites quality papers describing original and applied research
ideas and new findings on technological and theoretical aspects of
computing and software engineering. In particular, we welcome submissions
describing work on integrating new technologies into products and
applications, on experiences with existing and novel techniques, and on
the identification of unsolved challenges. We consider this meeting to be
an important forum to discuss experiences in applying computing and
software engineering to actual situations. Authors are invited to submit
papers in English or French, reporting recent research in the area of
computing and software development theories and practices and experience
in related fields. While research papers should report original research
work, experience and application papers should describe the development
and operations of challenging computing related systems and applications.
The symposium will have focused sessions in the following areas:

     * Algorithms and Theory
     * Artificial Intelligence and Related Subjects
     * Bio-medical,life science and medical computing
     * Computational Linguistics
     * Computing Applications
     * Core Computing Technology
     * Data Bases
     * E-Commerce
     * Ethics
     * Hardware and Architecture
     * Human-Computer Interaction
     * Open Source
     * Parallel Computing
     * Programming Languages
     * Privacy and Security
     * Software Engineering
     * Supercomputing
     * System Technology
     * Virtual Reality
     * Web Design and Development
     * Emerging computing technologies


The scope of the conference includes the above topics but is not
restricted to these areas in computing and software engineering: following
are some of the topics typically used by computer scientists to describe
their interests:

Algorithms, Applications, Artificial intelligence, Automata theory,
Automated reasoning, Bioinformatics, Compiler theory, Computability
theory, Computational complexity theory, Computational linguistic,
Computer architecture, Computer graphics, Computer programming, Computer
security, Computer vision, Concurrency, Cryptography, Data Models, Data
mining, Data structures, Data warehousing, Digital library, Distributed
computing, Expert Systems, Formal methods, Functional Programming, Game
theory, Graph theory, Human computer interaction, Image processing,
Information Retrieval, Knowledge base system, Machine learning, Machine
translation, Mathematical logic, Multimedia, Natural Language Processing,
Networking, Number theory, Numerical analysis, Operating systems, Parallel
computing, Programming language, Quantum computing theory, Reverse
engineering, Robotics, Scientific computing, Semantic Web, Semi-structured
data, Software engineering, Speech synthesis and recognition, Super
computing, Symbolic computation, Web database

Call for proposals for Workshop or Panels
-----------------------------------------

Proposals are invited for workshops or panels to be held in conjunction
with the symposium, in the areas of interest within the scope of
conference. The workshop papers would be published in the C3S2E
proceedings. The detailed proposals should reach the program chairs by
March 1, 2011.

Position Papers
~~~~~~~~~~~~~~~

In addition to regular papers, position papers are invited. These papers
could be work in progress and/or exploring of new concepts and directions.

Position papers should be clearly marked on the first page and for the
review purpose could be of a length varying from a short paper(6-10 pages)
to a regular full paper (15-20 pages).

Poster & Demos
~~~~~~~~~~~~~~

(see at the beginning)

Cultural/Social Events
~~~~~~~~~~~~~~~~~~~~~~

In addition to the conference dinner, there would be a guided tour of the
"The Warrior Emperor and China's Terracotta Army" at the Montreal Museum
of Fine Arts. According to the organizers "This Canadian national tour is
a newly developed and contextually different presentation than previous,
international displays. The number of full-sized warriors and the
exhibitions scope makes this the largest display of the First Emperors
terracotta army ever to be seen in North America."

Conference Publication
~~~~~~~~~~~~~~~~~~~~~~

The conference proceedings will be published by BytePress/ACM and would be
added to ACM's Digital Library. All submissions would also be invited to
publish their papers in the CINDI Digital Library. The extended version of
the best papers would also be recommended for publication in a special
edition of reputed journal.

Important Dates
~~~~~~~~~~~~~~~

All the dates are given on the milestone page on ConfSys for C3S2E
(accessible to registered users). The following are the salient ones:

ConfSys user Sign-Up begins:    Always on
Paper submission begins:        2010-11-01
Paper submission deadline:      2011-02-21 (EXTENDED)
Acceptance notice:              2011-03-25
Camera-ready copies deadline:   2011-04-15
Conference dates:               2011-05-16 -- 2011-05-18

Please visit the ConfSys (https://confsys.encs.concordia.ca/ConfSys) web
sites for further instructions. ConfSys is used to manage all
administrative functions of the conference.

Organized by
~~~~~~~~~~~~

Concordia University, Montreal, Canada;
with the cooperation of ACM, BytePress.org and ConfSys.org

General Chair:
Bipin C. Desai (Concordia University, Montreal, Canada)

Local Organization
Concordia University, Montreal, Canada

Program Chairs:
Alain Abran:  ETS - Univ. du Qubec (Canada)
Sudhir Mudur: Concordia Univesity (Canada)

Submission Guidelines
~~~~~~~~~~~~~~~~~~~~~

Please prepare the full paper in proportional font size of 11 or 12
(Times Roman font or equivalent) with spacing of 1.5 lines.
The paper, for review, should be about 5000 words (15-20 pages).
The upload to ConSys should be in PDF format. Please do not use any
special characters or foreign language fonts. Reviewers may
not be able to open such documents. Please observe the following:

FORM OF MANUSCRIPT

Manuscripts should be formatted for single sided letter or A4 sized
paper, with spacing of at least 1.5 lines with a 2.5cm margins on
all sides. Number pages consecutively with the first page containing
the title, the authors, the affiliation, a short abstract from 100
to 250 words, and five to ten key words. Also, indicated all the
topics for the paper from the list of topics for the conference in
ConfSys. Since these topics as well as the abstract will be used by
ConfSys to help the program committee members choose appropriate
papers, it is essential to make them as indicative of the contents
of the paper as possible.

Please see the instructions for preparing the paper for review in:

   http://confsys.encs.concordia.ca/c3s2e/c3s2e-11/PaperforReview.html

Preparing the paper for review. A sample paper is given in
smple paper:

  
http://confsys.encs.concordia.ca/c3s2e/c3s2e-11/ACM/sample/IDEAS-the-preteen-yea\
rs-1col.pdf

STATEMENT OF EXCLUSIVE SUBMISSION

Submissions must be original. The work cannot have been published previously or
be pending publication in another forum and
submissions cannot be under review by any other forum.

It is expected that all authors accept the following statement:

This paper (or a similar version) is not currently under review by a journal or
conference, nor will it be submitted to such
until the result of this review has been communicated. Furthermore, the
author(s) agree to abide by the decision of the Program
chairs and would participate in the meeting should the paper be accepted.

The author who submits a paper is expected to inform all co:authors of the
submission and has their approval.

Authors should submit only papers that have been carefully proofread and
polished. Papers that are clearly unacceptable will be
returned by the editor without being reviewed. Authors must clearly acknowledge
the contributions of their predecessors.

Submissions will be evaluated on their originality and significance.

Though a group of authors may submit multiple papers, we expect that each paper
would be presented by a separate co:author to
allow for a wider point of views during the presentations and discussions. The
authors are expected to upload the paper in PDF
format.

PDF format Guidelines

At a minimum, basic PDF distiller settings MUST be changed so PDF files are:
optimized, set to Acrobat 4.0 compatibility, all
graphics are set to at least 300 dpi resolution, ALL fonts used must be
embeddable. Some font manufacturers now flag their fonts
to not embed. These fonts should be avoided. Postscript settings SHOULD NOT
override distiller settings and page size is 612.0 x
792.0 points (8.5" x 11"). Authors should check their final PDF files before
submission to verify that all fonts have been
properly embedded and subset. Please DO NOT USE type 1 (bitmapped) fonts; they
do not display correctly in most PDF readers.

The program committee reserves the right to consider any paper, to be accepted
as a short paper or to be presented in a poster
or the workshop session. One of the authors of each accepted paper is expected
to present the paper in person.

C3S2E'11

Hi aima-talk list. i thought i understood how the degree heuristic worked on the
Australia 3-color problem but according to pg 216, it guarantees solving the
problem without backtracking and when i worked it out, that's not what i found.
Since i'm assuming Russel and Peter are smarter than i am, i must be making a
mistake, but i'm not sure where

Start:
SA is touching 5 unassigned variables
NT, Q, NSW = 3
WA, V = 2
T = 0

So far, this seems to agree with the book

Assign Red to SA

NT, Q, NSW = 2
WA, V = 1
T = 0

Assign Green to NT

NSW = 2
Q, V = 1
WA, T = 0

Assign Green to NSW

WA, Q, V, T = 0

When assigning green to NSW after NT=G, i've made the problem unsolvable

Any idea what i'm misunderstanding?

-baylor

just need some thoughts on "proof by contradiction" introduced on page 250 used
on page 254, 7th line from the end `...we wish to prove Alpha; which
is,say,¬P12`

according to proof by contradiction, it is : KB AND ¬Alpha ( we show is
unsatisfiable to prove KB entails Alpha)

but in the example, it is Alpha = ¬P12

So then ¬ Alpha is: ¬(¬P12), will become just P12 and so it is reflected in
Figure 7.13

Right?!

Need help...

Guys can you help me solve the exercises of chapter no 3, 4, 5, & 6 of this book
AIMA (Artificial Intelligence: A Modern Approach)...

Plz plz plz plz help me out..

> P(H|E) = P(H and E) / P(E)
This is the definition of Conditional Probability.

> P(H|E) = (P(E|H)*P(H))/P(E)
Bayes' Rule is derived from the definition of conditional probability.
Hence, all assumptions made in the definition of conditional probability
will be true even for Bayes' Rule

> Is it because the former requires P(H and E) assumes independence,
P(H and E) does not assume independence (or dependence for that matter).
It just represents joint distribution.

> Why is the definition of conditional probability not as useful as the
Bayes' Rule?
That is because in most applications, when you want to predict P(H|E),
the most estimable quantity that you have with you is P(E|H). For
example, if you want to predict what disease is afflicting a person
based on his symptoms i.e P(Disease | Symptoms), the data that you will
have with you is which diseases have what all symptoms, from which you
can estimate P(Symptoms | Disease).

Regards.

--- In aima-talk@yahoogroups.com, "Jim Davies" <jim.davies@...> wrote:
>
> P(H|E) = P(H and E) / P(E)
>
> is not as useful as Bayes' Rule
>
> P(H|E) = (P(E|H)*P(H))/P(E)
>
> But I'm not sure why. Is it because the former requires P(H and E)
assumes independence, which we might not have?
>
> JimDavies
>

I was going to assign problem 4.13 to my AI students as a good continuation of
3.7, but I find that it requires problem 4.11. I looked at problem 4.11 and the
part related with the percepts and the knowledge of the map is clear. However,
in problem 3.7 navigation is based on straight line segments between vertices of
the polygons. In problem 4.11, it is not clear what happens after the agent
stops where the path intersects an obstacle (second bullet). Should it compute
another path to try to get to the goal state, or start anew from a random
location. I am assuming it is using an online search algorithm.

Thanks for your collaboration,

Hi,

I am confused with the (revised!) description of GRAPH-SEARCH in AIMA 3/e. By
adding resulting nodes to the frontier *only* if not already there (or in the
explored set), the search tree "clearly [...] contains at most one copy of each
state" (p.77). This description was different in AIMA 2/e.

What about A* search, then, and the Romanian route finding problem in Figure
3.24? There, Bucharest is on the frontier twice, and has to be, because
otherwise A* would not find the shortest path.

Thanks for enlightening me,
Stephan

Hi AIMA community. We're getting into planning now and while i understand most
of the material in chapter 10, i don't understand how planning graphs are used
to extract heuristics that make searching for a plan faster

The 3rd edition mentions search goes faster with heuristics and planning graphs
can be used to generate heuristic values. i see how that works from the initial
state - the last goal literal appears at level 9 so the solution must be at
least 9 steps away. What i don't understand is how you calculate a value from
later states - if i'm at level 8 and literal A appears for the first time at
level 9, it doesn't mean i'm 1 action away from it, just as being at level 10
doesn't mean i've achieved it

i'm also confused as to how to use the heuristic information. If i'm at level 1,
literal A is at level 9 and i have 3 actions, the heuristic value for all 3
actions is the same isn't it? A heuristic doesn't help unless it makes one
action appear lower cost than the other

i re-read that section a couple of times but i feel like i'm missing something
really obvious

-baylor

I am considering signing up for the free online Stanford AI intro class being
taught by Norvig and Russell (the authors), and am trying to nail down the
logistics of getting the text book as an ebook. Using the class site's book
references, this is what I have found (so far) for an ebook version:

1.  Pearson claims it is "out of print" - an ebook?? Really?? Did they run out
of disk space?

2.  Barnes & Noble claim their version can only be obtained for use with
NookStudy, and thus only is readable on Windows or Mac, and not on Android or
Linux (or those i-thingies...).  Not a good option for me.

3. It appears that the Kindle version from Amazon is available for Android and
most other versions of Kindle readers, so is that the only viable ebook option
for Android?

TIA
R

I'm trying to use the aima-python code to use in the online ai-class course from
Standford. I'm new to python but have followed the instructions on the wiki
fully.  I have the latest svn version and the associated data downloaded.  The
following is the code I'm trying to run, and following that is the error.  If
anyone can help I would really appreciate it because I'm already falling behind
on the course trying to resolve this.

"""Run all doctests from modules on the command line.  Use -v for verbose.

Example usages:

     python doctests.py *.py
     python doctests.py -v *.py

You can add more module-level tests with
     __doc__ += "..."
You can add stochastic tests with
     __doc__ += random_tests("...")
"""

if __name__ == "__main__":
     import sys, glob, doctest
     args = sys.argv[1:]
     modules = [__import__(name.replace('-v *.py',''))
                for arg in args if arg != "-v" for name in glob.glob(arg)]
     for module in modules:
         doctest.testmod(module, report=1)
     print '%d failed out of %d' % doctest.master.summarize()

The responding error....

Traceback (most recent call last):
   File "C:\Python27\lib\bdb.py", line 383, in run
     exec cmd in globals, locals
   File "C:\Python27\aima\aima-python\doctests.py", line 12, in <module>
     """
AttributeError: 'NoneType' object has no attribute 'summarize'

I'm in the process of delving into and running the LISP program code
accessible in the site

http://aima.cs.berkeley.edu

for the 3rd edition of the venerable textbook.

I would recommend this procedure to everybody who is either studying
the book or lecturing based on it.  It gives more insight into the
algorithms presented in the book.

Ceterum censeo, I like the book very much.  I'm thinking if I could
honestly call this book the best computer science textbook that I ever have got
in my hands.  My PhD thesis is almost finished, but I decided to invest the time
to delving into the book to keep my knowledge on a par with the modern AI
practize.  As to keeping up with the modern AI research, I recommend getting and
reading the AAAI and IJCAI conference proceedings, as well as reading journals
such as the JACM.

(The manuscript of the thesis, which has some dozen known errata, is
http://www.tkk.fi/~ajy/diss.pdf .)

I would like to make a suggestion for the next edition of the book --
I mean, if one has been planned.  The reader could be suggested to
download from the 'Net the combination of 1) the GNU Emacs; and 2) the
SLIME; and 3) the GNU CLISP; for the work of running and delving into
the LISP code available at the aima.cs.berkley.edu site.

I mean, having a top-of-the-notch freeware LISP IDE (Integrated
Development Environment) at hand quite significantly helps this task
of getting to know and running the LISP code, compared to the
circumstances that the user of the LISP code only had in his/her hands
a bare LISP and an editor.  I could not any more think of carrying out
this task in that basic way.

The combination of the GNU Emacs, the SLIME and the CLISP I have
chosen beause:

1) The GNU Emacs is arguably the world's best character based text
editor.  See

http://www.gnu.org/software/emacs
http://http://en.wikipedia.org/wiki/Ediff

2) The SLIME is the Superior LISP Interaction Mode for EMACS.  To my
opinion it is the best available freeware LISP IDE (Integrated
Development Environment).  See

http://common-lisp.net/project/slime/
http://en.wikipedia.org/wiki/SLIME

3) I have chosen to suggest the CLISP out of some ten freeware Common
LISP implementations because of three aspects:

3.1 The CLISP is a relatively old implementation so many bugs have
been ironed out.

3.2 The CLISP is a part of the GNU system so there exists non-null
support for the software.

3.3. To my opinion it is a good Common LISP implementation.

See:

http://clisp.cons.org/
http://en.wikipedia.org/wiki/GNU_CLISP


kind regards and V/R, Antti J Ylikoski
Helsinki, Finland, the EU

The planner SensoryGraphPlan can be found, in an edited, tested and
working status, tested with GNU EMACS, SLIME and CLISP, in my web site
in

http://www.tkk.fi/~ajy/SensoryGraphPlan/

and its subdirectory domains/

Those files carry a copyright notice that they only may be copied and
used for noncommercial research purposes.  Therefore, all commercial
use of any of those files necessitates an explicit written permission
of the authors and copyright holders of the files.  Moreover, the
copyright notices in those files should not be removed.  I interpret
it that giving these files here for the readers of the AIMA discussion
group constitutes a "noncommercial research purpose".  I'm doing this
only for the purpose of furthering scientific discussion, no one gets
a single cent from this post.

On the AIMA pages, http://aima.cs.berkeley.edu, the LISP code, for the
book, pages concerning planning refer to the UCPOP system.  However,
when one accesses these UCPOP pages then the user will find the notice
that the UCPOP is an aging system, if I remember correctly, then the
UCPOP is not any more supported.

The UCPOP has been superseded by the SGP, the Sensory Graphplan.  The
www pages of the SGP are:

http://nth.wpi.edu/classes/AI-Stuff/SensoryGraphPlan/sgp/

this is a good planner for the student of the venerable textbook to
carry out exercises and various experiments with.


yours sincerely, and V/R, Mr Antti J Ylikoski
Helsinki, Finland, the EU

On the AIMA pages, http://aima.cs.berkeley.edu , the LISP code pages
concerning planning refer to the UCPOP system.  However, when one
accesses these UCPOP pages then the user will find the information that the
UCPOP is an aging system, IIRC then it is not any more supported.

The UCPOP has been superseded by the SGP, the Sensory Graphplan.  The
www pages of the SGP are:

http://nth.wpi.edu/classes/AI-Stuff/SensoryGraphPlan/sgp/

so this is where the user of the venerable textbook will have to look
for a good planner to carry out exercises and various experiments
with.

(I downloaded the LISP code of the SGP but I have not yet experimented
with it.  Experiences with the SGP LISP code would, I think, be highly
welcome here in the AIMA newsgroup.)

yours sincerely, and V/R, Mr Antti J Ylikoski "Andy"
Helsinki, Finland, the EU

I was able to reproduce this error by running "python doctests.py" with no
arguments. Apparently doctest.master starts out as None and gets initialized
when doctest.testmod() is called, so this is a bug in doctests.py. Can you run
"python doctests.py *.py" instead with no errors? This bug will have to be
fixed, of course, but it shouldn't affect anything else.

Darius

--- In aima-talk@yahoogroups.com, "damo_78@..." <damo_78@...> wrote:
>
> I'm trying to use the aima-python code to use in the online ai-class course
from Standford. I'm new to python but have followed the instructions on the wiki
fully.  I have the latest svn version and the associated data downloaded.  The
following is the code I'm trying to run, and following that is the error.  If
anyone can help I would really appreciate it because I'm already falling behind
on the course trying to resolve this.
>
> """Run all doctests from modules on the command line.  Use -v for verbose.
>
> Example usages:
>
>     python doctests.py *.py
>     python doctests.py -v *.py
>
> You can add more module-level tests with
>     __doc__ += "..."
> You can add stochastic tests with
>     __doc__ += random_tests("...")
> """
>
> if __name__ == "__main__":
>     import sys, glob, doctest
>     args = sys.argv[1:]
>     modules = [__import__(name.replace('-v *.py',''))
>                for arg in args if arg != "-v" for name in glob.glob(arg)]
>     for module in modules:
>         doctest.testmod(module, report=1)
>     print '%d failed out of %d' % doctest.master.summarize()
>
> The responding error....
>
> Traceback (most recent call last):
>   File "C:\Python27\lib\bdb.py", line 383, in run
>     exec cmd in globals, locals
>   File "C:\Python27\aima\aima-python\doctests.py", line 12, in <module>
>     """
> AttributeError: 'NoneType' object has no attribute 'summarize'
>

Is the book:

George F. Luger: Artificial Intelligence, Structures and Strategies for Complex
Problem Solving, 6th Edition, Addison-Wesley, ISBN 978-0-321-54589-3

mentioned in the list of AI books here in the AIMA site?

I feel that the Luger book could be added there as some very good supplementary
material for the AIMA book.  There are there in Luger's book some points which
the AIMA book does not discuss, such as Kohonen neural networks, and IIRC the
version-space algorithm in Prolog. And much of the Luger book suits as refresher
material for the venerable AIMA book.  Repetitio et mater studiorum!

The AIMA-Python project inspired me to study the Python code in the
AIMA site Python files.  It seems that I have discovered one bug in
those Python files.  (I might even dedicate some programmer hours to
the AIMA-Python project to contribute something for it.)

In the file agents.py there are there the instructions to run the
reflex agent in the vacuum world as follows:

--------------------------------------

__doc__ += """
>>> a = ReflexVacuumAgent()
>>> a.program((loc_A, 'Clean'))
'Right'
>>> a.program((loc_B, 'Clean'))
'Left'
>>> a.program((loc_A, 'Dirty'))
'Suck'
>>> a.program((loc_A, 'Dirty'))
'Suck'

--------------------------------------

which will not run.  The agents.py module first must be imported, and
after that the names in the module must be qualified with the module
name in order to be able to run them from the interactive mode.

The instructions should read (this way they will actually work)

--------------------------------------

>>> import agents
>>> a = agents.ReflexVacuumAgent()
>>> a.program((agents.loc_A, 'Clean'))
'Right'
>>> a.program((agents.loc_B, 'Clean'))
'Left'
>>> a.program((agents.loc_A, 'Dirty'))
'Suck'

--------------------------------------


Cheers, Antti J Ylikoski
Helsinki, Finland, the E.U.

Hi,

I happen to have a two questions about the Passive ADP Agent (21.2.2 in the 3rd
edition). I wonder if somebody could be so kind to answer them:

1. Why the agent updates utility of its policy every action (s(a)-s')? This
seems unnecessary.
2. Why this algorithm has "dynamic programming" in its name? It is a simple
counting of transition statistics + policy evaluation which is made by solving
linear algebra or iteration. So where is the dynamic programming here? Am I
missing something?

Thanks,
cauchy

I have read through Stuart Russell's lecture slides for the AIMA book,
from the AIMA site http://aima.cs.berkeley.edu.  They constitute
excellent refresher material for the book.

There is one small point that I would like to make concerning the
slides, the book and the accompanying LISP code.

File 09.  A nice LISP idiom for generating standardized apart names
is:

(intern (symbol-name (gensym "$STANDARD"))) ; for variable names
(intern (symbol-name (gensym "$SKOLEM")))   ; for Skolem functions

The point is that the above idioms are very simple and they will work
for all cases, without there being special cases for names which the
used must not type (well, except for really pathological cases such as
$STANDARD2013, but anyway.)

I hope that this constitutes a positive contribution for the excellent
book.


yours, Antti J Ylikoski
Helsinki, Finland, the E.U.
antti.ylikoski@...
http://www.tkk.fi/~ajy/

Hi,
I've tried to implement the back prop learning function from page 734
and ran it on the following examples:

double[][] inputs = {
	 {0.547361, -2.04845, -2.71647},
	 {1.9708, -1.16141, -0.0485735},
	 {-3.18799, 2.97068, 0.26499},
	 {-0.498425, -1.04703, 1.61744}
};

double[][] outputs = {
	 {1.0, 0.0, 0.0, 0.0},
	 {0.0, 1.0, 0.0, 0.0},
	 {0.0, 0.0, 1.0, 0.0},
	 {0.0, 0.0, 0.0, 1.0}
};

the problem is my network is unable to fully adapt itself to the data.
after 10000 iterations of the main loop I still have an error sum of around 6
units. The error doesn't converge to zero. Am I doing something wrong? I'd be
glad to share my Java code but I'm new in this group and have no idea how should
I post the code.
Cheers,
Matan.

I'm currently delving into the AIMA-Python modules.  In the module
games.py there was there something to correct: in order to be able to
run at all the play_game() function in the way that it is indicated in
the documentation, it is necessary to precede the call of the
play_game() function with a ">>> from games import *" statement.

Moreover, I made the play_game() function and the display() method of
the TicTacToe() class a little neater.

Try the games.py module with these changes.

------------------------------------------------------
# The play_game function of the games.py module.  AJY 04-07-2012.

def play_game(game, *players):
     """Play an n-person, move-alternating game.
     >>> from games import * # Added this. A. J. Y. 04-07-2012.
     >>> play_game(TicTacToe(), alphabeta_player, alphabeta_player) # Changed.
     0 # With correct play, it is always a draw.  AJY 04-07-2012.
     """
     state = game.initial
     while True:
         for player in players:
             move = player(game, state)
             state = game.result(state, move)
             game.display(state) # Added this.  A. J. Y. 04-07-2012.
             if game.terminal_test(state):
                 return game.utility(state, game.to_move(game.initial))

------------------------------------------------------
# The display method of the TicTacToe() class.  AJY 04-07-2012.

     def display(self, state):
         board = state.board
         print "\n" # Added this. A. J. Y. 04-07-2012.
         for x in range(1, self.h+1):
             for y in range(1, self.v+1):
                 print board.get((x, y), '.'),
             print
         print "\n" # Added this.  A. J. Y. 04-07-2012.

------------------------------------------------------


kind regards, Antti J Ylikoski
Helsinki, Finland, the E.U.

I don't see anything related to the robot navigation problem in the Online Code
Repository. Anyone have it?

--- In aima-talk@yahoogroups.com, Antti Ylikoski <antti.ylikoski@...> wrote:
> I'm currently delving into the AIMA-Python modules.  In the module
> games.py there was there something to correct: in order to be able to
> run at all the play_game() function in the way that it is indicated in
> the documentation, it is necessary to precede the call of the
> play_game() function with a ">>> from games import *" statement.

You can run the examples with "python doctests.py". It's standard in Python to
write examples assuming the import implicitly, because you always need to import
code to run it. Maybe the README should say something.

> Moreover, I made the play_game() function and the display() method of
> the TicTacToe() class a little neater.

I'd rather leave display() out of play_game() so it can be used to evaluate AI
players silently, e.g. for tournaments and training. Display in the players
instead, like query_player(). There is a need for a standard hook for these
displays to show up in a user interface, and it'd be reasonable for play_game to
emit events to such a hook. We've been leaning towards a web interface with
Javascript, though so far nobody's stepped up to do it.

I'm not sure about the extra newline for tictactoe's display -- generally it's
easier to add a newline in the caller than to remove a newline the caller wished
wasn't there, so the current scheme seems right to me. I've only made a quick
look right now, though. Thanks for the suggestion.

Darius

> Try the games.py module with these changes.
>
> ------------------------------------------------------
> # The play_game function of the games.py module.  AJY 04-07-2012.
>
> def play_game(game, *players):
>     """Play an n-person, move-alternating game.
>     >>> from games import * # Added this. A. J. Y. 04-07-2012.
>     >>> play_game(TicTacToe(), alphabeta_player, alphabeta_player) # Changed.
>     0 # With correct play, it is always a draw.  AJY 04-07-2012.
>     """
>     state = game.initial
>     while True:
>         for player in players:
>             move = player(game, state)
>             state = game.result(state, move)
>             game.display(state) # Added this.  A. J. Y. 04-07-2012.
>             if game.terminal_test(state):
>                 return game.utility(state, game.to_move(game.initial))
>
> ------------------------------------------------------
> # The display method of the TicTacToe() class.  AJY 04-07-2012.
>
>     def display(self, state):
>         board = state.board
>         print "\n" # Added this. A. J. Y. 04-07-2012.
>         for x in range(1, self.h+1):
>             for y in range(1, self.v+1):
>                 print board.get((x, y), '.'),
>             print
>         print "\n" # Added this.  A. J. Y. 04-07-2012.
>
> ------------------------------------------------------
>
>
> kind regards, Antti J Ylikoski
> Helsinki, Finland, the E.U.
>