/** * Applies the derivative of tanh to each of the elements in the vector. Returns a new matrix. */ 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 void set(double value) { for (int slice = 0; slice < numSlices; ++slice) { slices[slice].set(value); } }
public static SimpleMatrix oneHot(int index, int size) { SimpleMatrix m = new SimpleMatrix(size, 1); m.set(index, 1); return m; }
/** * Compute dot product between two vectors. */ 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()); } }
/** * Applies log to each of the entries in the matrix. Returns a new matrix. */ public static SimpleMatrix elementwiseApplyLog(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.log(output.get(i, j))); } } return output; }
/** * Concatenates several column vectors into one large column vector */ public static SimpleMatrix concatenate(SimpleMatrix ... vectors) { int size = 0; for (SimpleMatrix vector : vectors) { size += vector.numRows(); } SimpleMatrix result = new SimpleMatrix(size, 1); int index = 0; for (SimpleMatrix vector : vectors) { result.insertIntoThis(index, 0, vector); index += vector.numRows(); } return result; }
/** * Returns matrices of the right size for either binary or unary (terminal) classification */ SimpleMatrix randomClassificationMatrix() { SimpleMatrix score = new SimpleMatrix(numClasses, numHid + 1); double range = 1.0 / (Math.sqrt((double) numHid)); score.insertIntoThis(0, 0, SimpleMatrix.random(numClasses, numHid, -range, range, rand)); // bias column goes from 0 to 1 initially score.insertIntoThis(0, numHid, SimpleMatrix.random(numClasses, 1, 0.0, 1.0, rand)); return score.scale(op.trainOptions.scalingForInit); }
SimpleMatrix randomTransformMatrix() { SimpleMatrix binary = new SimpleMatrix(numHid, numHid * 2 + 1); // bias column values are initialized zero binary.insertIntoThis(0, 0, randomTransformBlock()); binary.insertIntoThis(0, numHid, randomTransformBlock()); return binary.scale(op.trainOptions.scalingForInit); }
/** * Returns the index with the highest value in the {@code predictions} matrix. * Indexed from 0. */ private static int getPredictedClass(SimpleMatrix predictions) { int argmax = 0; for (int i = 1; i < predictions.getNumElements(); ++i) { if (predictions.get(i) > predictions.get(argmax)) { argmax = i; } } return argmax; }
public SimpleMatrix getAnaphorEmbedding(SimpleMatrix mentionEmbedding) { return anaphorMatrix.mult(mentionEmbedding); }
/** * Creates a zero initialized tensor */ public SimpleTensor(int numRows, int numCols, int numSlices) { slices = new SimpleMatrix[numSlices]; for (int i = 0; i < numSlices; ++i) { slices[i] = new SimpleMatrix(numRows, numCols); } this.numRows = numRows; this.numCols = numCols; this.numSlices = numSlices; }
/** * Returns the sum of all elements in the tensor. */ public double elementSum() { double sum = 0.0; for (SimpleMatrix slice : slices) { sum += slice.elementSum(); } return sum; }
/** * Returns a randomly initialized tensor with values draft from the * uniform distribution between minValue and maxValue. */ public static SimpleTensor random(int numRows, int numCols, int numSlices, double minValue, double maxValue, java.util.Random rand) { SimpleTensor tensor = new SimpleTensor(numRows, numCols, numSlices); for (int i = 0; i < numSlices; ++i) { tensor.slices[i] = SimpleMatrix.random(numRows, numCols, minValue, maxValue, rand); } return tensor; }
/** * Applies tanh to each of the entries in the matrix. Returns a new matrix. */ 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; }
/** * Returns a vector with random Gaussian values, mean 0, std 1 */ public static SimpleMatrix randomGaussian(int numRows, int numCols, Random rand) { SimpleMatrix result = new SimpleMatrix(numRows, numCols); for (int i = 0; i < numRows; ++i) { for (int j = 0; j < numCols; ++j) { result.set(i, j, rand.nextGaussian()); } } return result; }
/** * Returns true iff every element of matrix is 0 */ public static boolean isZero(SimpleMatrix matrix) { int size = matrix.getNumElements(); for (int i = 0; i < size; ++i) { if (matrix.get(i) != 0.0) { return false; } } return true; } }
public SimpleMatrix getAntecedentEmbedding(SimpleMatrix mentionEmbedding) { return antecedentMatrix.mult(mentionEmbedding); }
/** <br>Will</br> overwrite an existing word vector */ public static void replaceWordVector(Map<String, SimpleMatrix> wordVectors, String source, String target) { if (!wordVectors.containsKey(source)) { return; } wordVectors.put(target, new SimpleMatrix(wordVectors.get(source))); }
public static void outputMatrix(BufferedWriter bout, SimpleMatrix matrix) throws IOException { for (int i = 0; i < matrix.getNumElements(); ++i) { bout.write(" " + matrix.get(i)); } bout.newLine(); }