Early 2017 Ideas Page
This page gathers together various ideas for new developers looking to cut their teeth on OpenCog, learn more about AI and proto-AGI, and be helpful in the process.
If you are an experienced OpenCog developer, feel free to add your ideas here.
Ideas Appropriate for 2017 Summer Interns
Simplified Pattern Matcher Syntax
Help design and implement a simplified syntax for the OpenCog Pattern Matcher. On the implementation level, this mostly involves writing some Guile (Scheme) macros. However, the meat of the project is figuring out what the simpler syntax should be. This is a non-trivial exercise in "mini-language design." Some experimentation will likely be necessary. The goal is to have OpenCog's Pattern Matcher as simple to code in as Neo4j's Cypher language.
Implement OpenCog Type Checker
Implement a type checker for OpenCog's PredicateNodes and SchemaNodes. This will need to do higher-order type checking, and ideally should handle dependent types in a manner broadly similar to Agda. This is appropriate for someone who has dealt with type-checking in functional languages before.
Multiple Atomspace Persistence
Extend the Postgres persistence backend to support saving multiple Atomspaces on the same database, and loading from different persisted Atomspaces onto the same in-RAM Atomspace.
Specialized Visualizer Layouts
Projects might involve
- Natural Language Processing oriented visualization (visualizing the multiple stages of the NL parsing and interpretation process)
- Attention allocation (ECAN) oriented visualization (visualizing the dynamics of the "attractor neural net" of attention values spreading around the Atomspace)
- Pattern mining oriented visualization (visualizing the results of the pattern miner)
- Inference oriented visualization (visualizing the inference chains of the PLN inference engine)
Jupyter Kernel for Guile
Since most people code OpenCog algorithms and applications in Guile Scheme, it would be useful to have a Jupyter kernel for Guile, for easy sharing of experiments, demos and for interactive tutorials. This project probably involves little to no OpenCog-specific code, it's mostly about implementing a new kernel according to the Jupyter project guidelines.
Example implementations for other scheme dialects
--perhaps this one? https://github.com/jerry40/guile-kernel although it hasn't been maintained for a while, and seems to work with a version of guile that's older than the one opencog uses
Graphviz Graph Plotting Scripts
This project makes sense if paired with the one above. Both guile and Jupyter have graphviz support, so it would make sense to build a library of graphviz plotting scripts for various common atomspace visualization tasks. This would produce static graphics, but it would make the Guile Jupyter notebooks far more useful.
Port Reduct to Atomspace
Re-implement the Reduct library from MOSES within the OpenCog Atomspace, using the OpenCog Rule Engine. This is an important part of the overall task of porting MOSES (our probabilistic evolutionary learning framework) into the Atomspace, where it belongs. (Reduct places programs, that are represented in tree format, into "elegant normal form", which increases the correlation between the syntactic distance and the semantic distance on program space, an important aspect of MOSES.)
Port core MOSES genetic programming algorithm to Atomspace
Make an initial port of MOSES, without Reduct-based normalization, to the Atomspace. Basically this means: create a genetic programming framework atop the Atomspace, with "islands" representing distinct population, and using Atom types appropriately to represent programs and fitness functions.
Port the Minecraft Interface to Microsoft Malmo
The current Minecraft interface uses ROS, which is convenient since it's also used in other robotics work. However, it would probably be better to use the official Minecraft interface for AI agents, [Malmo]. This would reduce maintenance and make it easier for new people to experiment with OpenCog and Minecraft together.
please insert ideas here! or in the appropriate categories above...
Port the Temporal Reasoning Python Code to the URE
Temporal reasoning is the next thing we need to give the AGIprime agent a certain awareness of time, and by that substantially improve OpenPsi. The goal would be to port, possibly fix and improve, the following to the new URE. If time permits experimenting with OpenPsi would be a plus.
URE on Classic Theorem-Proving Problems
This could be taken in several directions: e.g. implementing standard theorem-proving techniques on top of the URE, or using more of PLN's uncertain-reasoning capabilities in a theorem-proving context. Only a very simple start could viably be gotten done during the summer, but still this would be interesting.
Super cool would be to prove Goedel's incompleteness theorems, like they apparently did in here (note that I didn't read the paper), the latter is probably too ambitious for a GSoC though.
(these ideas are still appropriate for beginners, but may be too large for a summer internship)
please insert ideas here!