SGD refactor

This PR does a few things:
  

  1. Actual mini batch gradient descent implemented: The update is the average gradient over the batch of examples. 
  2. LinearSVM implementation: Perceptron and linear_svm are now implemented by a shared Hinge class. When threshold is set to 1.0, you get the loss used by SVM, when threshold is set to 0.0 you get the loss used by perceptron.

  3. SGDOptimizer: RegularizationUpdater and LearningRateComputation moved to an abstract SGDOptimizer class. This gives us the flexibility to define arbitrarily complicated REG/LR computations via a common interface. Some newly implemented SGDOptimizers include {AdagradOptimizer, PassiveAggressiveOptimizer, ElasticNetOptimizer, FTRLOptimizer (from the google ad click prediction paper)}. These all do 3 things basically:


    1. getUpdate(instance) - returns an skv with per feature gradient updates as a function of the subclass' learning rate/regularization schedule

    2. lazyUpdate (implements LazyVector.UpdateFunction)
    3. getDecreasingLearningRate - returns an exponentially decreasing learning rate used for things like truncation.

  4. HandsFree learning can now just be implemented as another SGDOptimizer class
  5. All SGDOptimizer classes can be used to optimize LeastSquares loss. For instance, by moving the PassiveAggressive class up to the SGDOptimizer level; now we can do PassiveAggressive regression.
  6. Subclasses of ULM only need to know how to do 3 things

    1. predict - returns a predicted val (w * x)
    2. loss - returns the per sample loss
    3. getGradients - returns a SKV with the first derivative of the loss function w.r.t. every non-zero model parameter

  7. UpdateableMulticlassLinearModel is now a concrete class that now holds a map[Category, UpdateableLinearModel], where the UpdateableLinearModel is selected in MultiClassModelTrainer. This means we can now do any combination of multi class {logistic regression, perceptron, linear_svm} with different optimizers {elastic net, adagrad, ftrl}

  8. Removed global_model bias from UpdateableLinearModel since I was the only one using it, it cluttered the interface internally, and there seems to be better ways to accomplish transfer learning

It seemed like that unnormalized gradient would be unchanged from "iter" to "iter" in the lazyUpdate function. My logic there was this:
*  LazyUpdate exists because the reg term has non-zero gradient at each time t, even tho the gradient for feature i at time t could be 0 (e.g. if feature i at time t is 0)
*  The lazyUpdate function "catches us up" on regularization for a feature i because we've gone (end - start) iterations without seeing a non-zero value for feature i
*  For every iter where the value of feature i is 0, the gradient is 0, so the update to unnormalized gradient is also 0 (and it never changes)
*  So, the value of unnormalized gradient should be the same from start to end, regardless of what "iter" it is.