float[] features = floatData.getValues(); return new FloatData(result, floatData.getSampleRate(), floatData.getFirstSampleNumber());
/** Sets the feature for this Token. * @param data features */ public void setData(Data data) { this.data = data; if (data instanceof FloatData) { collectTime = ((FloatData)data).getCollectTime(); } }
public float[] calculateComponentScore(Data data) { float[] features = FloatData.toFloatData(data).getValues(); int dim = meansInvVars.length / gconsts.length; if (features.length != dim) { String fmt = "feature vector must be of length %d, got %d"; String msg = String.format(fmt, dim, features.length); throw new IllegalArgumentException(msg); } float[] likelihoods = Arrays.copyOf(gconsts, gconsts.length); for (int i = 0; i < likelihoods.length; ++i) { for (int j = 0; j < features.length; ++j) { int k = i * features.length + j; likelihoods[i] += meansInvVars[k] * features[j]; likelihoods[i] -= .5f * invVars[k] * features[j] * features[j]; } likelihoods[i] = LogMath.getLogMath().lnToLog(likelihoods[i]); } return likelihoods; }
public void updateScores(Data feature) { if (feature instanceof DoubleData) System.err.println("DoubleData conversion required on mixture level!"); long firstSampleNumber = FloatData.toFloatData(feature).getFirstSampleNumber(); if (gauCalcSampleNumber != firstSampleNumber) { float[] featureVector = FloatData.toFloatData(feature).getValues(); updateScores(featureVector); gauCalcSampleNumber = firstSampleNumber; } }
/** * Converts DoubleData object to FloatDatas. * @param data data to convert * @return converted data */ public static DoubleData FloatData2DoubleData(FloatData data) { int numSamples = data.getValues().length; double[] doubleData = new double[numSamples]; float[] values = data.getValues(); for (int i = 0; i < values.length; i++) { doubleData[i] = values[i]; } return new DoubleData(doubleData, data.getSampleRate(), data.getFirstSampleNumber()); }
public float[] calculateComponentScore(Data feature){ return new float[((FloatData) feature).getValues().length]; }
/** * Converts a given Data-object into a <code>FloatData</code> if possible. * @param data data to convert * @return converted data */ public static FloatData toFloatData(Data data) { FloatData convertData; if (data instanceof FloatData) convertData = (FloatData) data; else if (data instanceof DoubleData) { DoubleData dd = (DoubleData) data; convertData = new FloatData(MatrixUtils.double2float(dd.getValues()), dd.getSampleRate(), dd.getFirstSampleNumber()); } else throw new IllegalArgumentException("data type '" + data.getClass() + "' is not supported"); return convertData; } }
public void updateTopScores(Data feature) { if (feature instanceof DoubleData) System.err.println("DoubleData conversion required on mixture level!"); long firstSampleNumber = FloatData.toFloatData(feature).getFirstSampleNumber(); if (toStoreScore) { curScores = getStoredScores(firstSampleNumber); } else { if (curScores != null && curScores.getFrameStartSample() != firstSampleNumber) curScores = null; } if (curScores != null) //component scores for this frame was already calculated return; float[] featureVector = FloatData.toFloatData(feature).getValues(); updateTopScores(featureVector); //store just calculated score in list curScores = createFromTopGau(firstSampleNumber); if (toStoreScore) storeScores(curScores); }
/** * Calculate the score for this mixture against the given feature. * <p> * Note: The support of <code>DoubleData</code>-features would require an array conversion to * float[]. Because getScore might be invoked with very high frequency, features are restricted * to be <code>FloatData</code>s. * * @param feature the feature to score * @return the score, in log, for the given feature */ public float getScore(FloatData feature) { return getScore(feature.getValues()); }
/** * Converts FloatData object to DoubleData. * @param data data to convert * @return converted data */ public static FloatData DoubleData2FloatData(DoubleData data) { int numSamples = data.getValues().length; float[] floatData = new float[numSamples]; double[] values = data.getValues(); for (int i = 0; i < values.length; i++) { floatData[i] = (float) values[i]; } return new FloatData(floatData, data.getSampleRate(), data.getFirstSampleNumber()); } }
/** * Converts DoubleData object to FloatDatas. * @param data data to convert * @return converted data */ public static DoubleData FloatData2DoubleData(FloatData data) { int numSamples = data.getValues().length; double[] doubleData = new double[numSamples]; float[] values = data.getValues(); for (int i = 0; i < values.length; i++) { doubleData[i] = values[i]; } return new DoubleData(doubleData, data.getSampleRate(), data.getFirstSampleNumber()); }
@Override public Data getData() throws DataProcessingException { Data d = getPredecessor().getData(); if (d instanceof DoubleData && convMode.equals(CONVERT_D2F)) { DoubleData dd = (DoubleData) d; d = new FloatData(MatrixUtils.double2float(dd.getValues()), dd.getSampleRate(), dd.getFirstSampleNumber()); } else if (d instanceof FloatData && convMode.equals(CONVERT_F2D)) { FloatData fd = (FloatData) d; d = new DoubleData(MatrixUtils.float2double(fd.getValues()), fd.getSampleRate(), fd.getFirstSampleNumber()); } return d; } }
/** * Calculates the scores for each component in the senone. * * @param feature the feature to score * @return the LogMath log scores for the feature, one for each component */ public float[] calculateComponentScore(Data feature) { if (feature instanceof DoubleData) System.err.println("DoubleData conversion required on mixture level!"); float[] featureVector = FloatData.toFloatData(feature).getValues(); float[] logComponentScore = new float[mixtureComponents.length]; for (int i = 0; i < mixtureComponents.length; i++) { // In linear form, this would be: // // Total += Mixture[i].score * MixtureWeight[i] logComponentScore[i] = mixtureComponents[i].getScore(featureVector) + mixtureWeights.get(id, 0, i); } return logComponentScore; }
public void updateScores(Data feature) { if (feature instanceof DoubleData) System.err.println("DoubleData conversion required on mixture level!"); long firstSampleNumber = FloatData.toFloatData(feature).getFirstSampleNumber(); if (gauCalcSampleNumber != firstSampleNumber) { float[] featureVector = FloatData.toFloatData(feature).getValues(); updateScores(featureVector); gauCalcSampleNumber = firstSampleNumber; } }
} else if (input instanceof FloatData) { FloatData fd = (FloatData) input; float[] values = fd.getValues(); System.out.print("Frame " + values.length); for (float val : values) {
/** * Computes the next feature. Advances the pointers as well. * * @return the feature Data computed */ @Override protected Data computeNextFeature() { DoubleData currentCepstrum = cepstraBuffer[currentPosition]; float[] feature = new float[(window * 2 + 1) * currentCepstrum.getValues().length]; int j = 0; for (int k = -window; k <= window; k++) { int position = (currentPosition + k + cepstraBufferSize) % cepstraBufferSize; double[] buffer = cepstraBuffer[position].getValues(); for (double val : buffer) { feature[j++] = (float)val; } } currentPosition = (currentPosition + 1) % cepstraBufferSize ; return (new FloatData(feature, currentCepstrum.getSampleRate(), currentCepstrum.getFirstSampleNumber())); } }
/** Sets the feature for this Token. * @param data features */ public void setData(Data data) { this.data = data; if (data instanceof FloatData) { collectTime = ((FloatData)data).getCollectTime(); } }
FloatData floatLastFeature = (FloatData) lastFeature; feature = new FloatData (floatLastFeature.getValues(), floatLastFeature.getSampleRate(), floatLastFeature.getFirstSampleNumber()); } else { DoubleData doubleLastFeature = (DoubleData)
@Override public float calculateScore(Data feature) { if (feature instanceof DoubleData) System.err.println("DoubleData conversion required on mixture level!"); float[] featureVector = FloatData.toFloatData(feature).getValues(); float logTotal = LogMath.LOG_ZERO; for (int i = 0; i < mixtureComponents.length; i++) { // In linear form, this would be: // // Total += Mixture[i].score * MixtureWeight[i] logTotal = logMath.addAsLinear(logTotal, mixtureComponents[i].getScore(featureVector) + mixtureWeights.get(id, 0, i)); } return logTotal; }
public void updateTopScores(Data feature) { if (feature instanceof DoubleData) System.err.println("DoubleData conversion required on mixture level!"); long firstSampleNumber = FloatData.toFloatData(feature).getFirstSampleNumber(); if (toStoreScore) { curScores = getStoredScores(firstSampleNumber); } else { if (curScores != null && curScores.getFrameStartSample() != firstSampleNumber) curScores = null; } if (curScores != null) //component scores for this frame was already calculated return; float[] featureVector = FloatData.toFloatData(feature).getValues(); updateTopScores(featureVector); //store just calculated score in list curScores = createFromTopGau(firstSampleNumber); if (toStoreScore) storeScores(curScores); }