LBJ Learning System

An LBJ Learning System is a Java-based learning-based programming environment (that uses a learning-based programming paradigm to facilitate the creation of learning programs).

• AKA: LBJ.
  • …
• Counter-Example(s):
  • a Java-based Machine Learning Library, such as MALLET and OpenNLP.
• See: Software Distribution, NLP Toolkit, Java-based Program, GNU Linear Programming Kit, Learning Based Program.

---

---

References

2011

• http://en.wikipedia.org/wiki/Learning_Based_Java
  • Learning Based Java (LBJ) is a special-purpose programming language based on Java and it is geared toward machine learning and natural language processing (NLP). It was developed at the Cognitive Computation Group of the University of Illinois at Urbana Champaign. Its implementation is distribution under the terms of a modified BSD license.

    LBJ is implemented as a compiler that translates LBJ programs to Java source code, which is then compiled to Java bytecode. It additionally trains any machine learning components of the program (based on a training set specified in the program). The resulting bytecode can be called as a library from any Java VM program.

    Learning components included in the LBJ libraries include AdaBoost, naïve Bayesian classifiers, perceptrons and sparse networks of winnows. Via interfaces to external libraries, support vector machines and the learners in the Weka toolkit are supported.

    LBJ further includes the ability to add constraint inference to the output of machine learners, following the Constrained Conditional Models paradigm. These constraints are expressed in a first-order logic language and can be used to, e.g., rule out certain results known to be impossible when using combinations of classifiers. Classification results and constraints are translated to linear/mixed integer programming problems, which are then solved using the GLPK or Xpress MP toolkits.

• http://cogcomp.cs.illinois.edu/page/software_view/11
  • Learning Based Java is a modeling language for the rapid development of software systems with one or more learned functions, designed for use with the Java^TM programming language. LBJ offers a convenient, declarative syntax for classifier and constraint definition directly in terms of the objects in the programmer's application. With LBJ, the details of feature extraction, learning, model evaluation, and inference are all abstracted away from the programmer, leaving him to reason more directly about his application. …

    … The LBJ compiler accepts the programmer's classifier and constraint specifications as input, automatically generating efficient Java code and applying learning algorithms (i.e., performing training) as necessary to implement the classifiers' entire computation from raw data (i.e., text, images, etc.) to output decision (i.e., part of speech tag, type of recognized object, etc.). The details of feature extraction, learning, model evaluation, and inference (i.e., reconciling the predictions in terms of the constraints at runtime) are abstracted away from the programmer.

    Under the LBJ programming philosophy, the designer of a learning based program will first design an object-oriented internal representation (IR) of the application's raw data using pure Java. For example, if we wish to write software dealing with emails, then we may wish to define a Java class named Email. An LBJ source file then allows the programmer to define classifiers that take Emails as input. A classifier is merely any method that produces one or more discrete or real valued classifications when given a single object from the programmer's IR. It might be hard-coded using explicit Java code (usually for use as a feature extractor), or learned from data (e.g., labeled example Emails) using other classifiers as feature extractors.

    Feature extraction and learning typically produce several different intermediate representations of the data they process. The LBJ compiler automates these processes, managing all of their intermediate representations automatically. An LBJ source file also acts as a Makefile of sorts. When you make a change to your LBJ source file, LBJ knows which operations need to be repeated. For example, when you change the code in a hard-coded classifier, only those learned classifiers that use it as a feature will be retrained. When you change only a learning algorithm parameter, LBJ skips feature extraction and goes straight to learning.

     LBJ is supported by a library of interfaces and classes that implement a standardized functionality for features and classifiers. The library includes learning and inference algorithm implementations, general purpose and domain specific internal representations, and domain specific parsers.

• http://cogcomp.cs.illinois.edu/page/project_view/23
  • … Learning Based Java (LBJ) is our implementation of LBP which accepts the practitioner's classification model as input, automatically generating efficient Java code that implements the trained classifier)'s entire computation from raw data to output decision. LBJ is best viewed as a programming framework in which the practitioner defines a classification model as a set of classifier specifications and a set of constraints over them. A classifier may be specified by
    • coding it explicitly in Java,
    • using operators to build it from existing classifiers,
    • or identifying feature extraction classifiers and a data source to learn it over.
  • The LBJ compiler then generates code and trains the learning classifiers as necessary, employing inference algorithms to resolve the constraints. Programming in LBJ, the practitioner reasons in terms of his data directly, disregarding the cumbersome details of learning and inference algorithm implementation.

2010

• (Rizzolo & Roth, 2010) ⇒ Nick Rizzolo, and Dan Roth. (2010). “Learning Based Java for Rapid Development of NLP Systems.” In: Proceedings of the International Conference on Language Resources and Evaluation (LREC 2010).

---