/// <param name="op">the parameters of the parser</param> public DVModel(Options op, IIndex <string> stateIndex, UnaryGrammar unaryGrammar, BinaryGrammar binaryGrammar) { this.op = op; rand = new Random(op.trainOptions.randomSeed); ReadWordVectors(); // Binary matrices will be n*2n+1, unary matrices will be n*n+1 numRows = op.lexOptions.numHid; numCols = op.lexOptions.numHid; // Build one matrix for each basic category. // We assume that each state that has the same basic // category is using the same transformation matrix. // Use TreeMap for because we want values to be // sorted by key later on when building theta vectors binaryTransform = TwoDimensionalMap.TreeMap(); unaryTransform = Generics.NewTreeMap(); binaryScore = TwoDimensionalMap.TreeMap(); unaryScore = Generics.NewTreeMap(); numBinaryMatrices = 0; numUnaryMatrices = 0; binaryTransformSize = numRows * (numCols * 2 + 1); unaryTransformSize = numRows * (numCols + 1); binaryScoreSize = numCols; unaryScoreSize = numCols; if (op.trainOptions.useContextWords) { binaryTransformSize += numRows * numCols * 2; unaryTransformSize += numRows * numCols * 2; } identity = SimpleMatrix.Identity(numRows); foreach (UnaryRule unaryRule in unaryGrammar) { // only make one matrix for each parent state, and only use the // basic category for that string childState = stateIndex.Get(unaryRule.child); string childBasic = BasicCategory(childState); AddRandomUnaryMatrix(childBasic); } foreach (BinaryRule binaryRule in binaryGrammar) { // only make one matrix for each parent state, and only use the // basic category for that string leftState = stateIndex.Get(binaryRule.leftChild); string leftBasic = BasicCategory(leftState); string rightState = stateIndex.Get(binaryRule.rightChild); string rightBasic = BasicCategory(rightState); AddRandomBinaryMatrix(leftBasic, rightBasic); } }
private SentimentModel(TwoDimensionalMap <string, string, SimpleMatrix> binaryTransform, TwoDimensionalMap <string, string, SimpleTensor> binaryTensors, TwoDimensionalMap <string, string, SimpleMatrix> binaryClassification, IDictionary <string, SimpleMatrix> unaryClassification, IDictionary <string, SimpleMatrix> wordVectors, RNNOptions op) { this.op = op; this.binaryTransform = binaryTransform; this.binaryTensors = binaryTensors; this.binaryClassification = binaryClassification; this.unaryClassification = unaryClassification; this.wordVectors = wordVectors; this.numClasses = op.numClasses; if (op.numHid <= 0) { int nh = 0; foreach (SimpleMatrix wv in wordVectors.Values) { nh = wv.GetNumElements(); } this.numHid = nh; } else { this.numHid = op.numHid; } this.numBinaryMatrices = binaryTransform.Size(); binaryTransformSize = numHid * (2 * numHid + 1); if (op.useTensors) { binaryTensorSize = numHid * numHid * numHid * 4; } else { binaryTensorSize = 0; } binaryClassificationSize = (op.combineClassification) ? 0 : numClasses * (numHid + 1); numUnaryMatrices = unaryClassification.Count; unaryClassificationSize = numClasses * (numHid + 1); rand = new Random(op.randomSeed); identity = SimpleMatrix.Identity(numHid); }
public DVModel(TwoDimensionalMap <string, string, SimpleMatrix> binaryTransform, IDictionary <string, SimpleMatrix> unaryTransform, TwoDimensionalMap <string, string, SimpleMatrix> binaryScore, IDictionary <string, SimpleMatrix> unaryScore, IDictionary <string, SimpleMatrix> wordVectors, Options op) { this.op = op; this.binaryTransform = binaryTransform; this.unaryTransform = unaryTransform; this.binaryScore = binaryScore; this.unaryScore = unaryScore; this.wordVectors = wordVectors; this.numBinaryMatrices = binaryTransform.Size(); this.numUnaryMatrices = unaryTransform.Count; if (numBinaryMatrices > 0) { this.binaryTransformSize = binaryTransform.GetEnumerator().Current.GetValue().GetNumElements(); this.binaryScoreSize = binaryScore.GetEnumerator().Current.GetValue().GetNumElements(); } else { this.binaryTransformSize = 0; this.binaryScoreSize = 0; } if (numUnaryMatrices > 0) { this.unaryTransformSize = unaryTransform.Values.GetEnumerator().Current.GetNumElements(); this.unaryScoreSize = unaryScore.Values.GetEnumerator().Current.GetNumElements(); } else { this.unaryTransformSize = 0; this.unaryScoreSize = 0; } this.numRows = op.lexOptions.numHid; this.numCols = op.lexOptions.numHid; this.identity = SimpleMatrix.Identity(numRows); this.rand = new Random(op.trainOptions.randomSeed); }
/// <summary>The traditional way of initializing an empty model suitable for training.</summary> public SentimentModel(RNNOptions op, IList <Tree> trainingTrees) { this.op = op; rand = new Random(op.randomSeed); if (op.randomWordVectors) { InitRandomWordVectors(trainingTrees); } else { ReadWordVectors(); } if (op.numHid > 0) { this.numHid = op.numHid; } else { int size = 0; foreach (SimpleMatrix vector in wordVectors.Values) { size = vector.GetNumElements(); break; } this.numHid = size; } TwoDimensionalSet <string, string> binaryProductions = TwoDimensionalSet.HashSet(); if (op.simplifiedModel) { binaryProductions.Add(string.Empty, string.Empty); } else { // TODO // figure out what binary productions we have in these trees // Note: the current sentiment training data does not actually // have any constituent labels throw new NotSupportedException("Not yet implemented"); } ICollection <string> unaryProductions = Generics.NewHashSet(); if (op.simplifiedModel) { unaryProductions.Add(string.Empty); } else { // TODO // figure out what unary productions we have in these trees (preterminals only, after the collapsing) throw new NotSupportedException("Not yet implemented"); } this.numClasses = op.numClasses; identity = SimpleMatrix.Identity(numHid); binaryTransform = TwoDimensionalMap.TreeMap(); binaryTensors = TwoDimensionalMap.TreeMap(); binaryClassification = TwoDimensionalMap.TreeMap(); // When making a flat model (no symantic untying) the // basicCategory function will return the same basic category for // all labels, so all entries will map to the same matrix foreach (Pair <string, string> binary in binaryProductions) { string left = BasicCategory(binary.first); string right = BasicCategory(binary.second); if (binaryTransform.Contains(left, right)) { continue; } binaryTransform.Put(left, right, RandomTransformMatrix()); if (op.useTensors) { binaryTensors.Put(left, right, RandomBinaryTensor()); } if (!op.combineClassification) { binaryClassification.Put(left, right, RandomClassificationMatrix()); } } numBinaryMatrices = binaryTransform.Size(); binaryTransformSize = numHid * (2 * numHid + 1); if (op.useTensors) { binaryTensorSize = numHid * numHid * numHid * 4; } else { binaryTensorSize = 0; } binaryClassificationSize = (op.combineClassification) ? 0 : numClasses * (numHid + 1); unaryClassification = Generics.NewTreeMap(); // When making a flat model (no symantic untying) the // basicCategory function will return the same basic category for // all labels, so all entries will map to the same matrix foreach (string unary in unaryProductions) { unary = BasicCategory(unary); if (unaryClassification.Contains(unary)) { continue; } unaryClassification[unary] = RandomClassificationMatrix(); } numUnaryMatrices = unaryClassification.Count; unaryClassificationSize = numClasses * (numHid + 1); }
// Maps from basic category to the matrix transformation matrices for // binary nodes and unary nodes. // The indices are the children categories. For binaryTransform, for // example, we have a matrix for each type of child that appears. // score matrices for each node type // cache these for easy calculation of "theta" parameter size // we just keep this here for convenience // the seed we used to use was 19580427 /// <exception cref="System.IO.IOException"/> /// <exception cref="System.TypeLoadException"/> private void ReadObject(ObjectInputStream @in) { @in.DefaultReadObject(); identity = SimpleMatrix.Identity(numRows); }