/// <summary>
/// Use the given
/// <paramref name="matrix"/>
/// in place of
/// <paramref name="slice"/>
/// .
/// Does not copy the
/// <paramref name="matrix"/>
/// , but rather uses the actual object.
/// </summary>
public virtual void SetSlice(int slice, SimpleMatrix matrix)
{
if (slice < 0 || slice >= numSlices)
{
throw new ArgumentException("Unexpected slice number " + slice + " for tensor with " + numSlices + " slices");
}
if (matrix.NumCols() != numCols)
{
throw new ArgumentException("Incompatible matrix size. Has " + matrix.NumCols() + " columns, tensor has " + numCols);
}
if (matrix.NumRows() != numRows)
{
throw new ArgumentException("Incompatible matrix size. Has " + matrix.NumRows() + " columns, tensor has " + numRows);
}
slices[slice] = matrix;
}
/// <summary>Applies the derivative of tanh to each of the elements in the vector.</summary>
/// <remarks>Applies the derivative of tanh to each of the elements in the vector. Returns a new matrix.</remarks>
public static SimpleMatrix ElementwiseApplyTanhDerivative(SimpleMatrix input)
{
SimpleMatrix output = new SimpleMatrix(input.NumRows(), input.NumCols());
output.Set(1.0);
output = output.Minus(input.ElementMult(input));
return(output);
}
public static IList <double> GetPredictionsAsStringList(Tree tree)
{
SimpleMatrix predictions = GetPredictions(tree);
IList <double> listOfPredictions = new List <double>();
for (int i = 0; i < predictions.NumRows(); i++)
{
listOfPredictions.Add(predictions.Get(i));
}
return(listOfPredictions);
}
/// <summary>Applies tanh to each of the entries in the matrix.</summary>
/// <remarks>Applies tanh to each of the entries in the matrix. Returns a new matrix.</remarks>
public static SimpleMatrix ElementwiseApplyTanh(SimpleMatrix input)
{
SimpleMatrix output = new SimpleMatrix(input);
for (int i = 0; i < output.NumRows(); ++i)
{
for (int j = 0; j < output.NumCols(); ++j)
{
output.Set(i, j, Math.Tanh(output.Get(i, j)));
}
}
return(output);
}
private static SimpleMatrix ComputeTensorDeltaDown(SimpleMatrix deltaFull, SimpleMatrix leftVector, SimpleMatrix rightVector, SimpleMatrix W, SimpleTensor Wt)
{
SimpleMatrix WTDelta = W.Transpose().Mult(deltaFull);
SimpleMatrix WTDeltaNoBias = WTDelta.ExtractMatrix(0, deltaFull.NumRows() * 2, 0, 1);
int size = deltaFull.GetNumElements();
SimpleMatrix deltaTensor = new SimpleMatrix(size * 2, 1);
SimpleMatrix fullVector = NeuralUtils.Concatenate(leftVector, rightVector);
for (int slice = 0; slice < size; ++slice)
{
SimpleMatrix scaledFullVector = fullVector.Scale(deltaFull.Get(slice));
deltaTensor = deltaTensor.Plus(Wt.GetSlice(slice).Plus(Wt.GetSlice(slice).Transpose()).Mult(scaledFullVector));
}
return(deltaTensor.Plus(WTDeltaNoBias));
}
/// <summary>Applies softmax to all of the elements of the matrix.</summary>
/// <remarks>
/// Applies softmax to all of the elements of the matrix. The return
/// matrix will have all of its elements sum to 1. If your matrix is
/// not already a vector, be sure this is what you actually want.
/// </remarks>
public static SimpleMatrix Softmax(SimpleMatrix input)
{
SimpleMatrix output = new SimpleMatrix(input);
for (int i = 0; i < output.NumRows(); ++i)
{
for (int j = 0; j < output.NumCols(); ++j)
{
output.Set(i, j, Math.Exp(output.Get(i, j)));
}
}
double sum = output.ElementSum();
// will be safe, since exp should never return 0
return(output.Scale(1.0 / sum));
}
/// <summary>Compute dot product between two vectors.</summary>
public static double Dot(SimpleMatrix vector1, SimpleMatrix vector2)
{
if (vector1.NumRows() == 1)
{
// vector1: row vector, assume that vector2 is a row vector too
return(vector1.Mult(vector2.Transpose()).Get(0));
}
else
{
if (vector1.NumCols() == 1)
{
// vector1: col vector, assume that vector2 is also a column vector.
return(vector1.Transpose().Mult(vector2).Get(0));
}
else
{
throw new AssertionError("Error in neural.Utils.dot: vector1 is a matrix " + vector1.NumRows() + " x " + vector1.NumCols());
}
}
}
/// <summary>
/// Returns a column vector where each entry is the nth bilinear
/// product of the nth slices of the two tensors.
/// </summary>
public virtual SimpleMatrix BilinearProducts(SimpleMatrix @in)
{
if (@in.NumCols() != 1)
{
throw new AssertionError("Expected a column vector");
}
if (@in.NumRows() != numCols)
{
throw new AssertionError("Number of rows in the input does not match number of columns in tensor");
}
if (numRows != numCols)
{
throw new AssertionError("Can only perform this operation on a SimpleTensor with square slices");
}
SimpleMatrix inT = @in.Transpose();
SimpleMatrix @out = new SimpleMatrix(numSlices, 1);
for (int slice = 0; slice < numSlices; ++slice)
{
double result = inT.Mult(slices[slice]).Mult(@in).Get(0);
@out.Set(slice, result);
}
return(@out);
}
private void BackpropDerivativesAndError(Tree tree, TwoDimensionalMap <string, string, SimpleMatrix> binaryTD, TwoDimensionalMap <string, string, SimpleMatrix> binaryCD, TwoDimensionalMap <string, string, SimpleTensor> binaryTensorTD, IDictionary
<string, SimpleMatrix> unaryCD, IDictionary <string, SimpleMatrix> wordVectorD, SimpleMatrix deltaUp)
{
if (tree.IsLeaf())
{
return;
}
SimpleMatrix currentVector = RNNCoreAnnotations.GetNodeVector(tree);
string category = tree.Label().Value();
category = model.BasicCategory(category);
// Build a vector that looks like 0,0,1,0,0 with an indicator for the correct class
SimpleMatrix goldLabel = new SimpleMatrix(model.numClasses, 1);
int goldClass = RNNCoreAnnotations.GetGoldClass(tree);
if (goldClass >= 0)
{
goldLabel.Set(goldClass, 1.0);
}
double nodeWeight = model.op.trainOptions.GetClassWeight(goldClass);
SimpleMatrix predictions = RNNCoreAnnotations.GetPredictions(tree);
// If this is an unlabeled class, set deltaClass to 0. We could
// make this more efficient by eliminating various of the below
// calculations, but this would be the easiest way to handle the
// unlabeled class
SimpleMatrix deltaClass = goldClass >= 0 ? predictions.Minus(goldLabel).Scale(nodeWeight) : new SimpleMatrix(predictions.NumRows(), predictions.NumCols());
SimpleMatrix localCD = deltaClass.Mult(NeuralUtils.ConcatenateWithBias(currentVector).Transpose());
double error = -(NeuralUtils.ElementwiseApplyLog(predictions).ElementMult(goldLabel).ElementSum());
error = error * nodeWeight;
RNNCoreAnnotations.SetPredictionError(tree, error);
if (tree.IsPreTerminal())
{
// below us is a word vector
unaryCD[category] = unaryCD[category].Plus(localCD);
string word = tree.Children()[0].Label().Value();
word = model.GetVocabWord(word);
//SimpleMatrix currentVectorDerivative = NeuralUtils.elementwiseApplyTanhDerivative(currentVector);
//SimpleMatrix deltaFromClass = model.getUnaryClassification(category).transpose().mult(deltaClass);
//SimpleMatrix deltaFull = deltaFromClass.extractMatrix(0, model.op.numHid, 0, 1).plus(deltaUp);
//SimpleMatrix wordDerivative = deltaFull.elementMult(currentVectorDerivative);
//wordVectorD.put(word, wordVectorD.get(word).plus(wordDerivative));
SimpleMatrix currentVectorDerivative = NeuralUtils.ElementwiseApplyTanhDerivative(currentVector);
SimpleMatrix deltaFromClass = model.GetUnaryClassification(category).Transpose().Mult(deltaClass);
deltaFromClass = deltaFromClass.ExtractMatrix(0, model.op.numHid, 0, 1).ElementMult(currentVectorDerivative);
SimpleMatrix deltaFull = deltaFromClass.Plus(deltaUp);
SimpleMatrix oldWordVectorD = wordVectorD[word];
if (oldWordVectorD == null)
{
wordVectorD[word] = deltaFull;
}
else
{
wordVectorD[word] = oldWordVectorD.Plus(deltaFull);
}
}
else
{
// Otherwise, this must be a binary node
string leftCategory = model.BasicCategory(tree.Children()[0].Label().Value());
string rightCategory = model.BasicCategory(tree.Children()[1].Label().Value());
if (model.op.combineClassification)
{
unaryCD[string.Empty] = unaryCD[string.Empty].Plus(localCD);
}
else
{
binaryCD.Put(leftCategory, rightCategory, binaryCD.Get(leftCategory, rightCategory).Plus(localCD));
}
SimpleMatrix currentVectorDerivative = NeuralUtils.ElementwiseApplyTanhDerivative(currentVector);
SimpleMatrix deltaFromClass = model.GetBinaryClassification(leftCategory, rightCategory).Transpose().Mult(deltaClass);
deltaFromClass = deltaFromClass.ExtractMatrix(0, model.op.numHid, 0, 1).ElementMult(currentVectorDerivative);
SimpleMatrix deltaFull = deltaFromClass.Plus(deltaUp);
SimpleMatrix leftVector = RNNCoreAnnotations.GetNodeVector(tree.Children()[0]);
SimpleMatrix rightVector = RNNCoreAnnotations.GetNodeVector(tree.Children()[1]);
SimpleMatrix childrenVector = NeuralUtils.ConcatenateWithBias(leftVector, rightVector);
SimpleMatrix W_df = deltaFull.Mult(childrenVector.Transpose());
binaryTD.Put(leftCategory, rightCategory, binaryTD.Get(leftCategory, rightCategory).Plus(W_df));
SimpleMatrix deltaDown;
if (model.op.useTensors)
{
SimpleTensor Wt_df = GetTensorGradient(deltaFull, leftVector, rightVector);
binaryTensorTD.Put(leftCategory, rightCategory, binaryTensorTD.Get(leftCategory, rightCategory).Plus(Wt_df));
deltaDown = ComputeTensorDeltaDown(deltaFull, leftVector, rightVector, model.GetBinaryTransform(leftCategory, rightCategory), model.GetBinaryTensor(leftCategory, rightCategory));
}
else
{
deltaDown = model.GetBinaryTransform(leftCategory, rightCategory).Transpose().Mult(deltaFull);
}
SimpleMatrix leftDerivative = NeuralUtils.ElementwiseApplyTanhDerivative(leftVector);
SimpleMatrix rightDerivative = NeuralUtils.ElementwiseApplyTanhDerivative(rightVector);
SimpleMatrix leftDeltaDown = deltaDown.ExtractMatrix(0, deltaFull.NumRows(), 0, 1);
SimpleMatrix rightDeltaDown = deltaDown.ExtractMatrix(deltaFull.NumRows(), deltaFull.NumRows() * 2, 0, 1);
BackpropDerivativesAndError(tree.Children()[0], binaryTD, binaryCD, binaryTensorTD, unaryCD, wordVectorD, leftDerivative.ElementMult(leftDeltaDown));
BackpropDerivativesAndError(tree.Children()[1], binaryTD, binaryCD, binaryTensorTD, unaryCD, wordVectorD, rightDerivative.ElementMult(rightDeltaDown));
}
}
private static double ScaleAndRegularize(IDictionary <string, SimpleMatrix> derivatives, IDictionary <string, SimpleMatrix> currentMatrices, double scale, double regCost, bool activeMatricesOnly, bool dropBiasColumn)
{
double cost = 0.0;
// the regularization cost
foreach (KeyValuePair <string, SimpleMatrix> entry in currentMatrices)
{
SimpleMatrix D = derivatives[entry.Key];
if (activeMatricesOnly && D == null)
{
// Fill in an emptpy matrix so the length of theta can match.
// TODO: might want to allow for sparse parameter vectors
derivatives[entry.Key] = new SimpleMatrix(entry.Value.NumRows(), entry.Value.NumCols());
continue;
}
SimpleMatrix regMatrix = entry.Value;
if (dropBiasColumn)
{
regMatrix = new SimpleMatrix(regMatrix);
regMatrix.InsertIntoThis(0, regMatrix.NumCols() - 1, new SimpleMatrix(regMatrix.NumRows(), 1));
}
D = D.Scale(scale).Plus(regMatrix.Scale(regCost));
derivatives[entry.Key] = D;
cost += regMatrix.ElementMult(regMatrix).ElementSum() * regCost / 2.0;
}
return(cost);
}
private static double ScaleAndRegularize(TwoDimensionalMap <string, string, SimpleMatrix> derivatives, TwoDimensionalMap <string, string, SimpleMatrix> currentMatrices, double scale, double regCost, bool dropBiasColumn)
{
double cost = 0.0;
// the regularization cost
foreach (TwoDimensionalMap.Entry <string, string, SimpleMatrix> entry in currentMatrices)
{
SimpleMatrix D = derivatives.Get(entry.GetFirstKey(), entry.GetSecondKey());
SimpleMatrix regMatrix = entry.GetValue();
if (dropBiasColumn)
{
regMatrix = new SimpleMatrix(regMatrix);
regMatrix.InsertIntoThis(0, regMatrix.NumCols() - 1, new SimpleMatrix(regMatrix.NumRows(), 1));
}
D = D.Scale(scale).Plus(regMatrix.Scale(regCost));
derivatives.Put(entry.GetFirstKey(), entry.GetSecondKey(), D);
cost += regMatrix.ElementMult(regMatrix).ElementSum() * regCost / 2.0;
}
return(cost);
}
/// <exception cref="System.IO.IOException"/>
public static void Main(string[] args)
{
string basePath = "/user/socherr/scr/projects/semComp/RNTN/src/params/";
int numSlices = 25;
bool useEscapedParens = false;
for (int argIndex = 0; argIndex < args.Length;)
{
if (Sharpen.Runtime.EqualsIgnoreCase(args[argIndex], "-slices"))
{
numSlices = System.Convert.ToInt32(args[argIndex + 1]);
argIndex += 2;
}
else
{
if (Sharpen.Runtime.EqualsIgnoreCase(args[argIndex], "-path"))
{
basePath = args[argIndex + 1];
argIndex += 2;
}
else
{
if (Sharpen.Runtime.EqualsIgnoreCase(args[argIndex], "-useEscapedParens"))
{
useEscapedParens = true;
argIndex += 1;
}
else
{
log.Info("Unknown argument " + args[argIndex]);
System.Environment.Exit(2);
}
}
}
}
SimpleMatrix[] slices = new SimpleMatrix[numSlices];
for (int i = 0; i < numSlices; ++i)
{
slices[i] = LoadMatrix(basePath + "bin/Wt_" + (i + 1) + ".bin", basePath + "Wt_" + (i + 1) + ".txt");
}
SimpleTensor tensor = new SimpleTensor(slices);
log.Info("W tensor size: " + tensor.NumRows() + "x" + tensor.NumCols() + "x" + tensor.NumSlices());
SimpleMatrix W = LoadMatrix(basePath + "bin/W.bin", basePath + "W.txt");
log.Info("W matrix size: " + W.NumRows() + "x" + W.NumCols());
SimpleMatrix Wcat = LoadMatrix(basePath + "bin/Wcat.bin", basePath + "Wcat.txt");
log.Info("W cat size: " + Wcat.NumRows() + "x" + Wcat.NumCols());
SimpleMatrix combinedWV = LoadMatrix(basePath + "bin/Wv.bin", basePath + "Wv.txt");
log.Info("Word matrix size: " + combinedWV.NumRows() + "x" + combinedWV.NumCols());
File vocabFile = new File(basePath + "vocab_1.txt");
if (!vocabFile.Exists())
{
vocabFile = new File(basePath + "words.txt");
}
IList <string> lines = Generics.NewArrayList();
foreach (string line in IOUtils.ReadLines(vocabFile))
{
lines.Add(line.Trim());
}
log.Info("Lines in vocab file: " + lines.Count);
IDictionary <string, SimpleMatrix> wordVectors = Generics.NewTreeMap();
for (int i_1 = 0; i_1 < lines.Count && i_1 < combinedWV.NumCols(); ++i_1)
{
string[] pieces = lines[i_1].Split(" +");
if (pieces.Length == 0 || pieces.Length > 1)
{
continue;
}
wordVectors[pieces[0]] = combinedWV.ExtractMatrix(0, numSlices, i_1, i_1 + 1);
if (pieces[0].Equals("UNK"))
{
wordVectors[SentimentModel.UnknownWord] = wordVectors["UNK"];
}
}
// If there is no ",", we first try to look for an HTML escaping,
// then fall back to "." as better than just a random word vector.
// Same for "``" and ";"
CopyWordVector(wordVectors, ",", ",");
CopyWordVector(wordVectors, ".", ",");
CopyWordVector(wordVectors, ";", ";");
CopyWordVector(wordVectors, ".", ";");
CopyWordVector(wordVectors, "``", "``");
CopyWordVector(wordVectors, "''", "``");
if (useEscapedParens)
{
ReplaceWordVector(wordVectors, "(", "-LRB-");
ReplaceWordVector(wordVectors, ")", "-RRB-");
}
RNNOptions op = new RNNOptions();
op.numHid = numSlices;
op.lowercaseWordVectors = false;
if (Wcat.NumRows() == 2)
{
op.classNames = new string[] { "Negative", "Positive" };
op.equivalenceClasses = new int[][] { new int[] { 0 }, new int[] { 1 } };
// TODO: set to null once old models are updated
op.numClasses = 2;
}
if (!wordVectors.Contains(SentimentModel.UnknownWord))
{
wordVectors[SentimentModel.UnknownWord] = SimpleMatrix.Random(numSlices, 1, -0.00001, 0.00001, new Random());
}
SentimentModel model = SentimentModel.ModelFromMatrices(W, Wcat, tensor, wordVectors, op);
model.SaveSerialized("matlab.ser.gz");
}
public virtual void BackpropDerivative(Tree tree, IList <string> words, IdentityHashMap <Tree, SimpleMatrix> nodeVectors, TwoDimensionalMap <string, string, SimpleMatrix> binaryW_dfs, IDictionary <string, SimpleMatrix> unaryW_dfs, TwoDimensionalMap
<string, string, SimpleMatrix> binaryScoreDerivatives, IDictionary <string, SimpleMatrix> unaryScoreDerivatives, IDictionary <string, SimpleMatrix> wordVectorDerivatives, SimpleMatrix deltaUp)
{
if (tree.IsLeaf())
{
return;
}
if (tree.IsPreTerminal())
{
if (op.trainOptions.trainWordVectors)
{
string word = tree.Children()[0].Label().Value();
word = dvModel.GetVocabWord(word);
// SimpleMatrix currentVector = nodeVectors.get(tree);
// SimpleMatrix currentVectorDerivative = nonlinearityVectorToDerivative(currentVector);
// SimpleMatrix derivative = deltaUp.elementMult(currentVectorDerivative);
SimpleMatrix derivative = deltaUp;
wordVectorDerivatives[word] = wordVectorDerivatives[word].Plus(derivative);
}
return;
}
SimpleMatrix currentVector = nodeVectors[tree];
SimpleMatrix currentVectorDerivative = NeuralUtils.ElementwiseApplyTanhDerivative(currentVector);
SimpleMatrix scoreW = dvModel.GetScoreWForNode(tree);
currentVectorDerivative = currentVectorDerivative.ElementMult(scoreW.Transpose());
// the delta that is used at the current nodes
SimpleMatrix deltaCurrent = deltaUp.Plus(currentVectorDerivative);
SimpleMatrix W = dvModel.GetWForNode(tree);
SimpleMatrix WTdelta = W.Transpose().Mult(deltaCurrent);
if (tree.Children().Length == 2)
{
//TODO: RS: Change to the nice "getWForNode" setup?
string leftLabel = dvModel.BasicCategory(tree.Children()[0].Label().Value());
string rightLabel = dvModel.BasicCategory(tree.Children()[1].Label().Value());
binaryScoreDerivatives.Put(leftLabel, rightLabel, binaryScoreDerivatives.Get(leftLabel, rightLabel).Plus(currentVector.Transpose()));
SimpleMatrix leftVector = nodeVectors[tree.Children()[0]];
SimpleMatrix rightVector = nodeVectors[tree.Children()[1]];
SimpleMatrix childrenVector = NeuralUtils.ConcatenateWithBias(leftVector, rightVector);
if (op.trainOptions.useContextWords)
{
childrenVector = ConcatenateContextWords(childrenVector, tree.GetSpan(), words);
}
SimpleMatrix W_df = deltaCurrent.Mult(childrenVector.Transpose());
binaryW_dfs.Put(leftLabel, rightLabel, binaryW_dfs.Get(leftLabel, rightLabel).Plus(W_df));
// and then recurse
SimpleMatrix leftDerivative = NeuralUtils.ElementwiseApplyTanhDerivative(leftVector);
SimpleMatrix rightDerivative = NeuralUtils.ElementwiseApplyTanhDerivative(rightVector);
SimpleMatrix leftWTDelta = WTdelta.ExtractMatrix(0, deltaCurrent.NumRows(), 0, 1);
SimpleMatrix rightWTDelta = WTdelta.ExtractMatrix(deltaCurrent.NumRows(), deltaCurrent.NumRows() * 2, 0, 1);
BackpropDerivative(tree.Children()[0], words, nodeVectors, binaryW_dfs, unaryW_dfs, binaryScoreDerivatives, unaryScoreDerivatives, wordVectorDerivatives, leftDerivative.ElementMult(leftWTDelta));
BackpropDerivative(tree.Children()[1], words, nodeVectors, binaryW_dfs, unaryW_dfs, binaryScoreDerivatives, unaryScoreDerivatives, wordVectorDerivatives, rightDerivative.ElementMult(rightWTDelta));
}
else
{
if (tree.Children().Length == 1)
{
string childLabel = dvModel.BasicCategory(tree.Children()[0].Label().Value());
unaryScoreDerivatives[childLabel] = unaryScoreDerivatives[childLabel].Plus(currentVector.Transpose());
SimpleMatrix childVector = nodeVectors[tree.Children()[0]];
SimpleMatrix childVectorWithBias = NeuralUtils.ConcatenateWithBias(childVector);
if (op.trainOptions.useContextWords)
{
childVectorWithBias = ConcatenateContextWords(childVectorWithBias, tree.GetSpan(), words);
}
SimpleMatrix W_df = deltaCurrent.Mult(childVectorWithBias.Transpose());
// System.out.println("unary backprop derivative for " + childLabel);
// System.out.println("Old transform:");
// System.out.println(unaryW_dfs.get(childLabel));
// System.out.println(" Delta:");
// System.out.println(W_df.scale(scale));
unaryW_dfs[childLabel] = unaryW_dfs[childLabel].Plus(W_df);
// and then recurse
SimpleMatrix childDerivative = NeuralUtils.ElementwiseApplyTanhDerivative(childVector);
//SimpleMatrix childDerivative = childVector;
SimpleMatrix childWTDelta = WTdelta.ExtractMatrix(0, deltaCurrent.NumRows(), 0, 1);
BackpropDerivative(tree.Children()[0], words, nodeVectors, binaryW_dfs, unaryW_dfs, binaryScoreDerivatives, unaryScoreDerivatives, wordVectorDerivatives, childDerivative.ElementMult(childWTDelta));
}
}
}
/// <exception cref="System.IO.IOException"/>
public static void Main(string[] args)
{
string modelPath = null;
string outputDir = null;
for (int argIndex = 0; argIndex < args.Length;)
{
if (Sharpen.Runtime.EqualsIgnoreCase(args[argIndex], "-model"))
{
modelPath = args[argIndex + 1];
argIndex += 2;
}
else
{
if (Sharpen.Runtime.EqualsIgnoreCase(args[argIndex], "-output"))
{
outputDir = args[argIndex + 1];
argIndex += 2;
}
else
{
log.Info("Unknown argument " + args[argIndex]);
Help();
}
}
}
if (outputDir == null || modelPath == null)
{
Help();
}
File outputFile = new File(outputDir);
FileSystem.CheckNotExistsOrFail(outputFile);
FileSystem.MkdirOrFail(outputFile);
LexicalizedParser parser = ((LexicalizedParser)LexicalizedParser.LoadModel(modelPath));
DVModel model = DVParser.GetModelFromLexicalizedParser(parser);
string binaryWDir = outputDir + File.separator + "binaryW";
FileSystem.MkdirOrFail(binaryWDir);
foreach (TwoDimensionalMap.Entry <string, string, SimpleMatrix> entry in model.binaryTransform)
{
string filename = binaryWDir + File.separator + entry.GetFirstKey() + "_" + entry.GetSecondKey() + ".txt";
DumpMatrix(filename, entry.GetValue());
}
string binaryScoreDir = outputDir + File.separator + "binaryScore";
FileSystem.MkdirOrFail(binaryScoreDir);
foreach (TwoDimensionalMap.Entry <string, string, SimpleMatrix> entry_1 in model.binaryScore)
{
string filename = binaryScoreDir + File.separator + entry_1.GetFirstKey() + "_" + entry_1.GetSecondKey() + ".txt";
DumpMatrix(filename, entry_1.GetValue());
}
string unaryWDir = outputDir + File.separator + "unaryW";
FileSystem.MkdirOrFail(unaryWDir);
foreach (KeyValuePair <string, SimpleMatrix> entry_2 in model.unaryTransform)
{
string filename = unaryWDir + File.separator + entry_2.Key + ".txt";
DumpMatrix(filename, entry_2.Value);
}
string unaryScoreDir = outputDir + File.separator + "unaryScore";
FileSystem.MkdirOrFail(unaryScoreDir);
foreach (KeyValuePair <string, SimpleMatrix> entry_3 in model.unaryScore)
{
string filename = unaryScoreDir + File.separator + entry_3.Key + ".txt";
DumpMatrix(filename, entry_3.Value);
}
string embeddingFile = outputDir + File.separator + "embeddings.txt";
FileWriter fout = new FileWriter(embeddingFile);
BufferedWriter bout = new BufferedWriter(fout);
foreach (KeyValuePair <string, SimpleMatrix> entry_4 in model.wordVectors)
{
bout.Write(entry_4.Key);
SimpleMatrix vector = entry_4.Value;
for (int i = 0; i < vector.NumRows(); ++i)
{
bout.Write(" " + vector.Get(i, 0));
}
bout.Write("\n");
}
bout.Close();
fout.Close();
}
