package edu.berkeley.nlp.classify.maxent;

import java.util.Collection;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.Vector;

import edu.berkeley.nlp.data.Datum;
import edu.berkeley.nlp.data.LabeledDatum;
import edu.berkeley.nlp.math.DifferentiableFunction;
import edu.berkeley.nlp.math.DoubleArrays;
import edu.berkeley.nlp.math.GradientMinimizer;
import edu.berkeley.nlp.math.IterationListener;
import edu.berkeley.nlp.math.LBFGSMinimizer;
import edu.berkeley.nlp.model.Learner;
import edu.berkeley.nlp.util.Indexer;

/**
* Factory for training MaximumEntropyClassifiers.
*
* @author rah67
*
* @param <F> Feature type -- almost always a String
* @param <L> Label (class) type
*/
public class MaximumEntropyClassifierFactory<F, L> implements Learner<F, F, L> {
private static final double DEFAULT_TOLERANCE = 1e-4;

private static final double DEFAULT_SIGMA = 1.0;

private static final int DEFAULT_ITERATIONS = 250;

private double sigma;

private int maxIterations;

private double tolerance;

public MaximumEntropyClassifierFactory() {
this(DEFAULT_SIGMA, DEFAULT_ITERATIONS, DEFAULT_TOLERANCE);
}

public MaximumEntropyClassifierFactory(double sigma, int maxIterations) {
this(sigma, maxIterations, DEFAULT_TOLERANCE);
}

/**
* Sigma controls the variance on the prior / penalty term. 1.0 is a
* reasonable value for large problems, bigger sigma means LESS smoothing.
* Zero sigma is a special indicator that no smoothing is to be done.
* <p/>
* Iterations determines the maximum number of iterations the optimization
* code can take before stopping.
*/
public MaximumEntropyClassifierFactory(double sigma, int maxIterations, double tolerance) {
this.sigma = sigma;
this.maxIterations = maxIterations;
this.tolerance = tolerance;
}

public MaximumEntropyClassifier<F, L> trainModel(Collection<? extends Datum<F>> trainingData) {
return trainModel(trainingData, null);
}

/**
* Trains a maximum entropy model. Before data is passed to this method
* the features should already have been extracted using a FeatureExtractor
*/
public MaximumEntropyClassifier<F, L> trainModel(
Collection<? extends Datum<F>> trainingData,
Collection<? extends Datum<F>> validationData) {
Collection<LabeledDatum<F, L>> lTrainingData = (Collection<LabeledDatum<F, L>>[Emoticon not found] trainingData;
Collection<LabeledDatum<F, L>> lValidationData = (Collection<LabeledDatum<F, L>>[Emoticon not found] validationData;

// build data encodings so the inner loops can be efficient
// TODO talk to Dan W. about encodings
Encoding<F, L> encoding = buildEncoding(lTrainingData, lValidationData);
IndexLinearizer indexLinearizer = new IndexLinearizer(encoding.getNumFeatures(), encoding.getNumLabels());
// TODO if we ever optimize theta, than we will have to fold validation later
EncodedDatum[] encodedData = encodeData(lTrainingData, lValidationData, encoding);
return trainModel(encodedData, encoding, indexLinearizer);
}

/**
* @param encodedData
* @param encoding
* @param indexLinearizer
* @return
*/
public MaximumEntropyClassifier<F, L> trainModel(EncodedDatum[] encodedData, Encoding<F, L> encoding, IndexLinearizer indexLinearizer) {
// build a minimizer object
GradientMinimizer minimizer = new LBFGSMinimizer(maxIterations, iterationListenerList);
// build the objective function for this data
DifferentiableFunction objective = new ObjectiveFunction<F, L>(
encoding, encodedData, indexLinearizer, sigma);
// learn our voting weights
double[] initialWeights = buildInitialWeights(encoding, indexLinearizer);
double[] weights = minimizer.minimize(objective, initialWeights,
tolerance);
// build a classifer using these weights (and the data encodings)
return new MaximumEntropyClassifier<F, L>(weights, encoding, indexLinearizer);
}

private Vector<IterationListener> iterationListenerList = new Vector<IterationListener>();
public void addIterationListener(IterationListener l) {
iterationListenerList.add(l);
}

public void removeIterationListener(IterationListener l) {
iterationListenerList.remove(l);
}

protected double[] buildInitialWeights(Encoding<F, L> encoding, IndexLinearizer indexLinearizer) {
// double[] weights = new double[indexLinearizer.getNumLinearIndexes()];
// Random random = new Random();
// for(int i = 0; i < weights.length; i++) {
// weights[i] = random.nextDouble() * perturbationFactor - perturbationFactor / 2.0;
// }
// return weights;
// return DoubleArrays.constantArray(0.0, indexLinearizer.getNumLinearIndexes());
return new double[indexLinearizer.getNumLinearIndexes()];
}

public static <F, L> Encoding<F, L> buildEncoding(
Collection<LabeledDatum<F, L>> trainingData) {
return buildEncoding(trainingData, null);
}

public static <F, L> Encoding<F, L> buildEncoding(
Collection<LabeledDatum<F, L>> trainingData,
Collection<LabeledDatum<F, L>> validationData) {
Indexer<F> featureIndexer = new Indexer<F>();
Indexer<L> labelIndexer = new Indexer<L>();
index(trainingData, labelIndexer, featureIndexer);
if (validationData != null)
index(validationData, labelIndexer, featureIndexer);
return new Encoding<F, L>(featureIndexer, labelIndexer);
}

private static <F, L> void index(Collection<LabeledDatum<F, L>> trainingData, Indexer<L> labelIndexer, Indexer<F> featureIndexer) {
for (LabeledDatum<F, L> labeledDatum : trainingData) {
labelIndexer.add(labeledDatum.getLabel());
for (F feature : labeledDatum.getFeatures()) {
featureIndexer.add(feature);
}
}
}

public static <F, L> EncodedDatum<F, L>[] encodeData(
Collection<LabeledDatum<F, L>> trainingData,
Encoding<F, L> encoding) {
return encodeData(trainingData, null, encoding);
}

public static <F, L> EncodedDatum<F, L>[] encodeData(
Collection<LabeledDatum<F, L>> trainingData,
Collection<LabeledDatum<F, L>> validationData, Encoding<F, L> encoding) {
int size = trainingData.size();

if (validationData != null)
size += validationData.size();

EncodedDatum[] encodedData = new EncodedDatum[size];
int i = 0;
for (LabeledDatum<F, L> labeledDatum : trainingData) {
encodedData[i++] = EncodedDatum.encodeLabeledDatum(labeledDatum, encoding);
}
if (validationData != null) {
for (LabeledDatum<F, L> labeledDatum : validationData) {
encodedData[i++] = EncodedDatum.encodeLabeledDatum(labeledDatum, encoding);
}
}
return encodedData;
}

/**
* @return the iterations
*/
public int getMaxIterations() {
return maxIterations;
}

/**
* @param iterations the iterations to set
*/
public void setMaxIterations(int iterations) {
this.maxIterations = iterations;
}

/**
* @return the sigma
*/
public double getSigma() {
return sigma;
}

/**
* @param sigma the sigma to set
*/
public void setSigma(double sigma) {
this.sigma = sigma;
}

/**
* @return the tolerance
*/
public double getTolerance() {
return tolerance;
}

/**
* @param tolerance the tolerance to set
*/
public void setTolerance(double tolerance) {
this.tolerance = tolerance;
}

/**
* @return the perturbationFactor
*/
/* public double getPerturbationFactor() {
return perturbationFactor;
}
*/
/**
* @param perturbationFactor the perturbationFactor to set
*/
/* public void setPerturbationFactor(double perturbationFactor) {
this.perturbationFactor = perturbationFactor;
}
*/
}

%s/[.,;"'?!a-zA-Z_01-9()-]//g

// make sure the dynamic dialog box is open
dialog.say('dynamicd',{pos:3,dir:'r'});
}

http://sg80bab.blogspot.com/2007/03/is-my-mac-using-too-much-memory.html

http://www.cs.rice.edu/~ssiyer/minstrels/poems/409.html

call2actionContact

and these:

list-style-image: none;

shelven

http://www.rememberthemilk.com/services/gmail/

#CF1A1C

castleworks great danes

http://play.rhapsody.com/lionelhampton/jukeboxhits19431950/lavendercoffin

http://www.basicinstructions.net/images/153gracefully.gif

VISUAL DIFFERENCE AND VARIETY IN INTERPRETATION ANALYSIS

is the data stored on S3

NZJDDH

http://www.illustratortechniques.com/forum/showthread.php?p=6749#post6749

http://justinhileman.info/blog/2008/02/im-so-over-itunes#comment-486

21:40:27
Saturday
23/02/08

<my friend's email address>

good question. i'll ask my connection

http://tinyurl.com/ypoqn4

http://tinyurl.com/ypoqn4

(apparently i haven't copied anything since last time...)

http://www.jarviedigital.com/projects/08charity/jamie-s/