Update ml.md to shorten the AIMA project

[sambitdash]

If there is further trimming required will be happy to do so.

Refer to https://github.com/JuliaLang/julialang.github.com/pull/726 for comments.

@ChrisRackauckas, pls. review the content.

[ChrisRackauckas]

It really doesn't need to be all that much. Just one maybe two paragraph into. A few lines for expected results, a few lines for recommended skills. The rest of the details should be tailored to the student via discussions with the mentors and the community. Take some of the others as examples, like:

https://github.com/JuliaLang/julialang.github.com/blob/master/soc/projects/compiler.md#thread-safety

[ChrisRackauckas]

IMO it seems like there's two concrete projects there: an information abstraction algorithm and algorithms for search problems. A good approach to condense this is to write specifically for those two separately.

1. What is the information abstraction problem? What does it solve? What algorithm is used? How would it be built? What kind of test should it pass at the end of the summer?
2. What is the search problem? What does it solve? What algorithm is used? How would it be built? What kind of test should it pass at the end of the summer?

[sambitdash]

No the intent is to just take all the sample code and make them into a library with proper abstractions.

The problems proposed were just examples to distinguish AI and ML.

[ChrisRackauckas]

Then I have misunderstood what the proposed project is. What algorithms are you specifically asking the student to implement? Note that normally these are undergraduate students (with a few graduate students), so it's good to have a narrow scope and choose a specific thing to do rather than leave it open ended (or if it is somewhat open, then it should explain concrete paths).

[sambitdash]

I am going chapter wise, initial chapters have more sample code and later chapters have lesser sample code. So guess chapter 4-12 will be a good target for a month's activity. Is that what the duration of engagement is?

The intent is to preserve the sample code as much as practicable to the details to which it is described in the book. No own interpretation is needed for the core algorithm. Make it a method without side effects.

When you implement the example or sample code you may use data structures or algorithms from Julia's standard libraries or take custom implementations. And pass all such DS as parameters to functions such that the parameters can be changed for another implementation. Example: One may use a queue from standard data structure but the Queue could have been a database query supported by an SQL in the backend. Essentially, code should accept any DS which supports the queue trait.

For example: In UniformCosSearch technique, You can use any Priority Queue, Set or State objects as long as the traits are validated in the constructor

execute is a set of commands which is almost a verbatim representation of the code in the book.

[ChrisRackauckas]

I took your text and cut out the parts which are not related to SoC. Here's what I came up with:

AIMA is a seminal text on representation of agents that (can aid solve a problem for an environment of varying complexity ? That needs work). Most packages available today as AI libraries tend to focus on ML only and not the architectural aspect of AI. Very few will talk about representational aspects of AI. The scope of the project is to create a library of core algorithms and sample programs separated out neatly such that core algorithms can be used by practitioners for abstract problem representations. ( What algorithms? What's needs to be done? )

Recommended Skills: previous experience with AI or the ability to quickly pick up on the AI algorithms in AIMA

Expected Results: ?

Hopefully that template puts us back on the right track.

[sambitdash]

Let me clarify a bit further:

1. This is a software engineering project or a pure coding project not a research or scientific project.
2. If you look at the N-Queens Problem you can see the same problem definition can use the following search algorithm just changing the SearchAlgorithms: a. GraphSearchAlgorithms
   1. Depth First
   2. Breadth First
   3. Iterative Depth First
   4. A* algorithms b. Genetic Algorithm c. Simulated Annealing
3. You can do so very easily as you are following the interface definition of a Problem, SearchAlgorithm verbatim as described in the book.
4. These abstractions are very useful for an engineering practitioner.

The same interfaces can be used to solve real life applications as well if the abstractions are kept pure.

The intent of the project is to take all such algorithms described in the book as called out sections (if you look at the book those are clearly placed in well outlined sections) and reproduce them in Julia (it's so well written almost all of them can be described in Julia as is) so that some one using those can use the same algorithms for production applications.

Also will suggest to read the full description, I originally provided to justify why such a representation is important.

[ChrisRackauckas]

Here's suggested text given the statement above. Let's discuss it from here:

AIMA is a seminal text on representation of agents to solve AI problems. Most packages available today as AI libraries tend to focus on ML only and not the architectural aspect of AI. The scope of the project is to create a library of core algorithms and sample programs using the AIMA example code. The student will implement and optimize Julia versions of algorithms like depth-first search and simulated annealing. These implementations will be tested in real-world applications. Starter code can be found at AIMACore along with AIMASamples.

Recommended Skills: Previous experience with AI or the ability to quickly pick up on the AI algorithms in AIMA

Expected Results: A well-documented library of functions derived from the AIMA book.

[ChrisRackauckas]

Separate from the question of the text, I'm curious about the why. Why are these implementations of graph search algorithms better than the LightGraphs versions to justify a second library? Why are these implementations of optimization algorithms better than the Optim and BlackBoxOptim versions to justify another library? I don't really understand with the examples you've given how to convey to the student that they will be adding a unique and useful feature to the Julia ecosystem that can/will gain adoption.

[sambitdash]

These are best interfaces ever designed for AI. It's the interfaces that I am interested in. Not the implementations. Change the interfaces of Optim or all the packages to support the interfaces defined in this book. They will be perfect for addressing larger classes of AI problem. Let me say this is the STL or boost of AI. People love those libraries for their usage ease and variety of problems they solve. Not to address one critical application of data structure to their problem set.

[sambitdash]

@ChrisRackauckas, find one implementation in the industry or code anywhere just mere changing of the algorithm you can use the same code to use graph search vs. genetic algorithm. That is the power of the interfaces or framework. That makes code easy to use or later to maintain.

[ChrisRackauckas]

These are best interfaces ever designed for AI. It's the interfaces that I am interested in. Not the implementations. Change the interfaces of Optim or all the packages to support the interfaces defined in this book. They will be perfect for addressing larger classes of AI problem.

So it's about the interface and not about the choice of algorithms? That wasn't mentioned in the previous texts and would be good to highlight if that's the case.

[ChrisRackauckas]

How's this then?

AIMA is a seminal text on representation of agents to solve AI problems. Most packages available today as AI libraries tend to focus on ML only and not the architectural aspect of AI. The scope of the project is to create a library with a clean API (following AIMA) to easily allow the application of core algorithms to AI problems. The student will implement a package that brings together implementations of algorithms like depth-first search and simulated annealing, both from other Julia packages and from sample code in the AIMA book, and build sample programs to demonstrate AI applications. Starter code can be found at AIMACore along with AIMASamples.

Recommended Skills: Previous experience with AI or the ability to quickly pick up on the AI algorithms in AIMA

Expected Results: A well-documented library of functions derived from the AIMA book.

[sambitdash]

"both from other Julia packages and from sample code"

From other Julia packages, immediately will be a tall order for now. I was trying to do the same for Genetic Algorithm for my problem set and found a lot of effort in doing so. For now it may be just enough to implement the algos verbatim from the book. The next phase will be to impress upon package designers to provide interfaces for this package or implement connectors to other packages from this package if there is adoption.

The text as you have written definitely conveys the core intent of the project to certain extent. Please, go ahead with your text..

[ChrisRackauckas]

Well the authors of many packages, including LightGraphs and Optim, are GSoC mentors. So if it's hard to use them to solve AI problems, then massaging them to an API that makes it easier would be a great GSoC. They can just talk with those individuals and get the necessary changes to make it happen.

[ChrisRackauckas]

Let's get someone else to double check.

[ChrisRackauckas]

@ViralBShah can we get a second pair of eyes on this. I made some big changes so I want to make sure someone else agrees before merging. Thanks.

[ViralBShah]

Thanks. @sambitdash If you want to stick the longer description into a gist and link it here, we can do that too - that way we have the best of both worlds.

[sambitdash]

Gist at: https://gist.github.com/sambitdash/ba7f798e378fce3b4cd1ab9326bc7d77