LambdaSolve (Stanford CoreNLP API)

java.lang.Object
- edu.stanford.nlp.maxent.iis.LambdaSolve

Direct Known Subclasses:

LambdaSolveTagger
```
public class LambdaSolve
extends Object
```
This is the main class that does the core computation in IIS. (Parts of it still get invoked in the POS tagger, even when not using IIS.)

Author:

Kristina Toutanova

Field Summary

Fields
Modifier and Type	Field and Description
`protected double`	`eps` Only used in the IIS optimization routines.
`protected byte[][]`	`fnumArr` This contains the number of features active for each pair (x,y)
`protected double[]`	`ftildeArr` This is an array of empirical expectations for the features
`double[]`	`lambda` These are the model parameters that have to be learned.
`protected boolean[]`	`lambda_converged` Only allocated and used in the IIS optimization routines.
`protected Problem`	`p`
`protected double[][]`	`probConds` Conditional probabilities.
`boolean`	`weightRanks`
`protected double[]`	`zlambda` Normalization factors, one for each x.

Constructor Summary

Constructors
Constructor and Description
`LambdaSolve()`
`LambdaSolve(Problem p1, double eps1, double nerr1)`
`LambdaSolve(String filename)` Reads the lambda parameters from a file.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`checkCorrectness()` Check whether the constraints are satisfied, the probabilities sum to one, etc.
`static double`	`divide(double first, double second)` Given a numerator and denominator in log form, this calculates the conditional model probabilities.
`double`	`expectedValue()` Each pair x,y has a value in p.data.values[x][y]
`protected double`	`fnum(int x, int y)`
`double`	`GainCompute(Feature f, double errorGain)` Computes the gain from a feature.
`double[]`	`getDerivatives()` assuming we have the lambdas in the array and we need only the derivatives now.
`double[]`	`getDerivativesExpectedValue()` assuming we have the probConds[x][y] , compute the derivatives for the expectedValue function
`double[]`	`getDerivativesLossDomination()` Using the arrays calculated when computing the loss, it should not be too hard to get the derivatives.
`double[]`	`getDerivativesNeg()` assuming we have the lambdas in the array and we need only the derivatives now.
`void`	`improvedIterative()` Iterate until convergence.
`void`	`improvedIterative(int iters)` Does a fixed number of IIS iterations.
`double`	`logLikelihood()`
`double`	`logLikelihoodNeg()` Calculate the log-likelihood from scratch, hashing the conditional probabilities in pcond, which we will use later.
`double`	`logLikelihoodScratch()` calculate the log likelihood from scratch, hashing the conditional probabilities in pcond which we will use for the derivative later.
`double`	`lossDomination()` calculate the loss for Dom ranking using the numbers in p.data.values to determine domination relationships in the graphs if values[x][y]> values[x][y'] then there is an edge (x,y)->(x,y')
`static void`	`main(String[] args)` With arguments, this will print out the lambda parameters of a bunch of .lam files (which are assumed to all be the same size).
`double`	`pcond(int y, int x)`
`void`	`print()` Print out p(y\|x) for all pairs to the standard output.
`static double[]`	`read_lambdas(DataInputStream rf)` Read the lambdas from the stream.
`void`	`readL(String filename)` Read the lambdas from the file.
`static void`	`save_lambdas(DataOutputStream rf, double[] lambdas)` Writes the lambdas to a stream.
`void`	`save_lambdas(String filename)` Writes the lambda feature weights to the file.
`void`	`setBinary()`
`void`	`setNonBinary()`
`void`	`transformValues()` This is a specialized procedure to change the values of parses for semantic ranking.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - lambda
```
public double[] lambda
```
    These are the model parameters that have to be learned. This field is used at runtime in all tagger and other IIS/Kristina code.
  - lambda_converged
```
protected boolean[] lambda_converged
```
    Only allocated and used in the IIS optimization routines.
  - eps
```
protected double eps
```
    Only used in the IIS optimization routines. Convergence threshold / allowed "newtonErr"
  - p
```
protected Problem p
```
  - probConds
```
protected double[][] probConds
```
    Conditional probabilities.
  - zlambda
```
protected double[] zlambda
```
    Normalization factors, one for each x. (CDM questions 2008: Are these only at training time? Can we not allocate it at test time (unlike what LambdaSolveTagger now does)? Is the place where it is set from ySize wrong?
  - fnumArr
```
protected byte[][] fnumArr
```
    This contains the number of features active for each pair (x,y)
  - ftildeArr
```
protected double[] ftildeArr
```
    This is an array of empirical expectations for the features
  - weightRanks
```
public boolean weightRanks
```
- Constructor Detail
  - LambdaSolve
```
public LambdaSolve(Problem p1,
           double eps1,
           double nerr1)
```
  - LambdaSolve
```
public LambdaSolve(String filename)
```
    Reads the lambda parameters from a file.
    
    Parameters:
    filename - File to read from
  - LambdaSolve
```
public LambdaSolve()
```
- Method Detail
  - setNonBinary
```
public void setNonBinary()
```
  - setBinary
```
public void setBinary()
```
  - transformValues
```
public void transformValues()
```
    This is a specialized procedure to change the values of parses for semantic ranking. The highest value is changed to 2/3 and values of 1 are changed to 1/(3*numones). 0 is unchanged this is used to rank higher the ordering for the best parse values are in p.data.values
  - improvedIterative
```
public void improvedIterative()
```
    Iterate until convergence. I usually use the other method that does a fixed number of iterations.
  - improvedIterative
```
public void improvedIterative(int iters)
```
    Does a fixed number of IIS iterations.
    
    Parameters:
    iters - Number of iterations to run
  - pcond
```
public double pcond(int y,
           int x)
```
  - fnum
```
protected double fnum(int x,
          int y)
```
  - checkCorrectness
```
public boolean checkCorrectness()
```
    Check whether the constraints are satisfied, the probabilities sum to one, etc. Prints out a message if there is something wrong.
  - GainCompute
```
public double GainCompute(Feature f,
                 double errorGain)
```
    Computes the gain from a feature. Used for feature selection.
  - print
```
public void print()
```
    Print out p(y|x) for all pairs to the standard output.
  - save_lambdas
```
public void save_lambdas(String filename)
```
    Writes the lambda feature weights to the file. Can be read later with readL. This method opens a new file and closes it after writing it.
    
    Parameters:
    filename - The file to write the weights to.
  - save_lambdas
```
public static void save_lambdas(DataOutputStream rf,
                double[] lambdas)
```
    Writes the lambdas to a stream.
  - readL
```
public void readL(String filename)
```
    Read the lambdas from the file. The file contains the number of lambda weights (int) followed by the weights. Historical note: The file does not contain xSize and ySize as for the method read(String).
    
    Parameters:
    filename - The file to read from
  - read_lambdas
```
public static double[] read_lambdas(DataInputStream rf)
```
    Read the lambdas from the stream.
    
    Parameters:
    rf - Stream to read from.
    
    Returns:
    An array of lambda values read from the stream.
  - logLikelihood
```
public double logLikelihood()
```
    Returns:
    The loglikelihood of the empirical distribution as predicted by the model p.
  - divide
```
public static double divide(double first,
            double second)
```
    Given a numerator and denominator in log form, this calculates the conditional model probabilities.
    
    Returns:
    Math.exp(first)/Math.exp(second);
  - main
```
public static void main(String[] args)
```
    With arguments, this will print out the lambda parameters of a bunch of .lam files (which are assumed to all be the same size). (Without arguments, it does some creaky old self-test.)
    
    Parameters:
    args - command line arguments
  - logLikelihoodNeg
```
public double logLikelihoodNeg()
```
    Calculate the log-likelihood from scratch, hashing the conditional probabilities in pcond, which we will use later. This is for a different model, in which all features effectively get negative weights this model is easier to use for heauristic search p(ti|s)=exp(sum_j{-(e^lambda_j)*f_j(ti)})
    
    Returns:
    The negative log likelihood of the data
  - logLikelihoodScratch
```
public double logLikelihoodScratch()
```
    calculate the log likelihood from scratch, hashing the conditional probabilities in pcond which we will use for the derivative later.
    
    Returns:
    The log likelihood of the data
  - getDerivatives
```
public double[] getDerivatives()
```
    assuming we have the lambdas in the array and we need only the derivatives now.
  - getDerivativesNeg
```
public double[] getDerivativesNeg()
```
    assuming we have the lambdas in the array and we need only the derivatives now. this is for the case where the model is parameterezied such that all weights are negative see also logLikelihoodNeg
  - expectedValue
```
public double expectedValue()
```
    Each pair x,y has a value in p.data.values[x][y]
    
    Returns:
    - expected value of corpus -sum_xy (ptilde(x,y)*value(x,y)*pcond(x,y))
  - getDerivativesExpectedValue
```
public double[] getDerivativesExpectedValue()
```
    assuming we have the probConds[x][y] , compute the derivatives for the expectedValue function
    
    Returns:
    The derivatives of the expected
  - lossDomination
```
public double lossDomination()
```
    calculate the loss for Dom ranking using the numbers in p.data.values to determine domination relationships in the graphs if values[x][y]> values[x][y'] then there is an edge (x,y)->(x,y')
    
    Returns:
    The loss
  - getDerivativesLossDomination
```
public double[] getDerivativesLossDomination()
```
    Using the arrays calculated when computing the loss, it should not be too hard to get the derivatives.
    
    Returns:
    The derivative of the loss

Class LambdaSolve

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

lambda

lambda_converged

eps

p

probConds

zlambda

fnumArr

ftildeArr

weightRanks

Constructor Detail

LambdaSolve

LambdaSolve

LambdaSolve

Method Detail

setNonBinary

setBinary

transformValues

improvedIterative

improvedIterative

pcond

fnum

checkCorrectness

GainCompute

print

save_lambdas

save_lambdas

readL

read_lambdas

logLikelihood

divide

main

logLikelihoodNeg

logLikelihoodScratch

getDerivatives

getDerivativesNeg

expectedValue

getDerivativesExpectedValue

lossDomination

getDerivativesLossDomination