In order to build a Scientific Reference Parser, I am contemplating a kind of "AI" system, and would like to know if something similar is already an established "design pattern" in AI research.
The input for the system would be Scientific References with structures like the following:
"Co-authors, title, Journal, volume, issue, begin page, year"
Of course, many other variations are possible, and I want to build a system that can make "best guesses" in case of unfamiliar patterns.
At the moment this is done by manually chaining the results of different methods together, ranging from Regex patterns to more complex algorithms like N-Grams, LSH and random forests. I contemplate a AI system that automatically "chains" all these methods together in the most optimal way. The way I imagine this to work is by means of what I call "a bag of functions". So, how would this work?
- For each of the methods I use at the moment, I would specify their input requirements, and specify what they provide as output. (e.g.: input = reference, output = title). These could also be parameters like: input = year, output = is valid year? . Note that if a function outputs "title" that is an attempt at providing the title, but this is not necessarily correct (if for example, the regex pattern grabbed a wrong portion of text).
- For each of these functions, I would build a training set, and log their execution time (cost) and their probability of providing a correct result.
- Then, I would build a system that chains these functions together to get from a certain input, to a certain output. eg: from -a function that takes a reference, and outputs the list of co authors- to -a function that takes a list of co authors, and breaks it apart into separate authors- to -a function that takes an author, and tries to break it apart into last name and initial-.
- Once a "chain" of functions is found, this chain can in turn be stored as a "function" and can be reused later on by the algorithm. For each function, the success rate and run time is stored, so the algorithm can choose to go for the fastest known route, or experiment with new functions.
- In the settings you could specify the max run time (cost) or the minimum success rate. This way you could push the system to experiment with new combinations of functions.
I'm not sure I explained the intent clearly, and I'm not sure the design would hold once I try to implement this in reality. Just wanted to throw this out here to see if anyone recognizes the design. This feels like a combination of a shortest path algorithm (to connect the functions) with normal statistical probability (to determine the success rate of a function) with a "self learning" system (because combinations of functions can be "remembered" and reused).
The added advantage would be that I don't need to manually guess what parsing method I should give a higher or lower likelihood of being correct in what specific scenario. It would allow me to just "throw" a new function into the bag, and let the system test it in all kinds of configurations, learning when best to use it, and when to avoid it.
Any feedback would be greatly appreciated! :)