AGILEPack [NOT ACTIVELY MAINTAINED]

Algorithms for Generalized Inference, Learning, and Extraction Package, By Luke de Oliveira.

####Dependencies

• Eigen matrix library (header only) for fast matrix operations.
• Compiler support for C++11. If you're not sure and want to cross check your compiler version to see if it's ok, here's some support info about GCC and Clang. Other compilers haven't been tested yet.

####Summary

This is a work in progress, with the ultimate goal of a versatile Deep Learning library in C++. Support will be provided for interfacing with *.root files and providing complete training and testing specifications within the YAML specification and serialization file.

####Installation

The package can be downloaded using

git clone https://github.com/lukedeo/AGILEPack.git

and is relatively basic to install. As long as Eigen is in a place such that

#include <Eigen/Dense>

won't cause your compiler to yell at you, you should be able to build the whole shebang with

make -j

This will build a static library called lib/libAGILEPack.a, which you can then link against to do sweet things like build deep nets for physics.

####Command line usage

AGILEPack ships with a command line interface for training. Run ./AGILEPackTrainer --help for more info.

####Basic Usage (API)

Let's say you have a program called prog.cxx that uses AGILEPack with ROOT stuff. Provided that your file takes the form

#include "Base"
           ^~~~~~ Includes all AGILEPack stuff!
#include <myotherheaders.h>

int main(int argc, char const *argv[])
{
	// Do stuff with AGILEPack!
}

You can compile this program with:

g++ -o prog prog.cxx `/path/to/AGILEPack/agile-config build --root`  
              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^
      fixes include paths and links -lAGILEPack

which will produce an excecutable called prog.

The ordering of these arguments is very important on Linux (particularly on SLC)!

####More compiling and linking stuff

Let's say you're using AGILEPack as part of a larger project, and you need to produce a *.o and then then do other things. Stealing the example from the last section, let's say we want to produce prog.o. We can do this with

g++ -c `/path/to/AGILEPack/agile-config compile --root` prog.cxx -o prog.o

then link it to other stuff with

g++ -o MyExcecutable prog.o [other *.o ...] `/path/to/AGILEPack/agile-config link --root`

####Algorithms and General Features

• Backpropagation for arbitrary layer structure.
• Support for:
  • Linear layers with SSE loss.
  • Sigmoidal layers with SSE loss.
  • Softmax layers with Cross Entropy loss.
  • Rectified linear unit layers.
  • Autoencoder pre-training (stacked, denoising, etc.)
  • Dropout/DropConnect layers.
• Dynamic changes to layers (additions, deletions).
• Interface with the CERN ROOT framework.
• Complete serialization of network structure with YAML file.
• More to come...

####I have qualms with AGILEPack

If there's something wrong with anything here, please bother me at lukedeo@stanford.edu.