Java tutorial
/** * Copyright 2000-2009 DFKI GmbH. * All Rights Reserved. Use is subject to license terms. * * This file is part of MARY TTS. * * MARY TTS is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, version 3 of the License. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. * */ package marytts.tools.voiceimport; import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.LineNumberReader; import java.util.ArrayList; import java.util.List; import java.util.SortedMap; import java.util.TreeMap; import marytts.cart.StringPredictionTree; import marytts.features.FeatureDefinition; import marytts.features.FeatureVector; import marytts.machinelearning.GmmDiscretizer; import weka.classifiers.trees.j48.BinC45ModelSelection; import weka.classifiers.trees.j48.C45PruneableClassifierTree; import weka.classifiers.trees.j48.TreeConverter; import weka.core.Attribute; import weka.core.DenseInstance; import weka.core.Instance; import weka.core.Instances; /* * This Class traverses intonised xml-files, and labeller files and trains a duration * model to predict the labeled durations from the features of the xml file * */ public class PauseDurationTrainer extends VoiceImportComponent { /** * Tuple holding list of feature vectors and feature definition. */ private class VectorsAndDefinition { public VectorsAndDefinition(List<FeatureVector> fv, FeatureDefinition fd) { this.fv = fv; this.fd = fd; } private List<FeatureVector> fv; private FeatureDefinition fd; public List<FeatureVector> getFv() { return fv; } public void setFv(List<FeatureVector> fv) { this.fv = fv; } public FeatureDefinition getFd() { return fd; } public void setFd(FeatureDefinition fd) { this.fd = fd; } } // maybe specify in config file? public final String[] featureNames = new String[] { "breakindex", "ph_cplace", "ph_ctype", "next_pos", "next_wordbegin_ctype", "next_wordbegin_cplace", "words_from_phrase_end", "words_from_phrase_start"/**/ }; // feature files used for training ("pause features") public final String FVFILES = "PauseDurationTrainer.featureDir"; // label files providing durations public final String LABFILES = "PauseDurationTrainer.lab"; // resulting trained decision tree public final String TRAINEDTREE = "PauseDurationTrainer.tree"; protected DatabaseLayout db = null; private String fvExt = ".pfeats"; private String labExt = ".lab"; public SortedMap<String, String> getDefaultProps(DatabaseLayout db) { this.db = db; if (props == null) { props = new TreeMap<String, String>(); // dir with pause feature files String pauseFv = System.getProperty(FVFILES); if (pauseFv == null) { pauseFv = db.getProp(db.ROOTDIR) + "pausefeatures" + System.getProperty("file.separator"); } props.put(FVFILES, pauseFv); // dir with lab files containing the pause durations String labs = System.getProperty(LABFILES); if (labs == null) { labs = db.getProp(db.ROOTDIR) + "lab" + System.getProperty("file.separator"); } props.put(LABFILES, labs); // resulting decision tree String tree = System.getProperty(TRAINEDTREE); if (tree == null) { tree = db.getProp(db.ROOTDIR) + "durations.tree"; } props.put(TRAINEDTREE, tree); } return props; } public boolean compute() throws Exception { // object to store all instances Instances data = null; FeatureDefinition fd = null; // pause durations are added at the end // all of them are collected first // then discretized List<Integer> durs = new ArrayList<Integer>(); for (int i = 0; i < bnl.getLength(); i++) { VectorsAndDefinition features = this.readFeaturesFor(bnl.getName(i)); if (null == features) continue; List<FeatureVector> vectors = features.getFv(); fd = features.getFd(); if (data == null) data = initData(fd); // reader for label file. BufferedReader lab = new BufferedReader(new FileReader(getProp(LABFILES) + bnl.getName(i) + labExt)); List<String> labSyms = new ArrayList<String>(); List<Integer> labDurs = new ArrayList<Integer>(); int prevTime = 0; int currTime = 0; String line; while ((line = lab.readLine()) != null) { if (line.startsWith("#")) continue; String[] lineLmnts = line.split("\\s+"); if (lineLmnts.length != 3) throw new IllegalArgumentException( "Expected three columns in label file, got " + lineLmnts.length); labSyms.add(lineLmnts[2]); // collect durations currTime = (int) (1000 * Float.parseFloat(lineLmnts[0])); int dur = currTime - prevTime; labDurs.add(dur); prevTime = currTime; } int symbolFeature = fd.getFeatureIndex("phone"); int breakindexFeature = fd.getFeatureIndex("breakindex"); int currLabelNr = 0; // treatment of first pause(s)... while (labSyms.get(currLabelNr).equals("_")) currLabelNr++; for (FeatureVector fv : vectors) { String fvSym = fv.getFeatureAsString(symbolFeature, fd); // all pauses on feature vector side are ignored, they are captured within boundary treatment if (fvSym.equals("_")) continue; if (!fvSym.equals(labSyms.get(currLabelNr))) throw new IllegalArgumentException("Phone symbol of label file (" + fvSym + ") and of feature vector (" + labSyms.get(currLabelNr) + ") don't correspond. Run CorrectedTranscriptionAligner first."); int pauseDur = 0; // durations are taken from pauses on label side if ((currLabelNr + 1) < labSyms.size() && labSyms.get(currLabelNr + 1).equals("_")) { currLabelNr++; pauseDur = labDurs.get(currLabelNr); } int bi = fv.getFeatureAsInt(breakindexFeature); if (bi > 1) { // add new training point with fv durs.add(pauseDur); data.add(createInstance(data, fd, fv)); } // for each break index > 1 currLabelNr++; } // for each featurevector } // for each file // set duration target attribute data = enterDurations(data, durs); // train classifier StringPredictionTree wagonTree = trainTree(data, fd); FileWriter fw = new FileWriter(getProp(TRAINEDTREE)); fw.write(wagonTree.toString()); fw.close(); return true; } private StringPredictionTree trainTree(Instances data, FeatureDefinition fd) throws Exception { System.out.println("training duration tree (" + data.numInstances() + " instances) ..."); // build the tree without using the J48 wrapper class // standard parameters are: // binary split selection with minimum x instances at the leaves, tree is pruned, confidence value, subtree raising, // cleanup, don't collapse C45PruneableClassifierTree decisionTree = new C45PruneableClassifierTree( new BinC45ModelSelection(2, data, true), true, 0.25f, true, true, false); decisionTree.buildClassifier(data); System.out.println("...done"); return TreeConverter.c45toStringPredictionTree(decisionTree, fd, data); } private Instances enterDurations(Instances data, List<Integer> durs) { // System.out.println("discretizing durations..."); // now discretize and set target attributes (= pause durations) // for that, first train discretizer GmmDiscretizer discr = GmmDiscretizer.trainDiscretizer(durs, 6, true); // used to store the collected values ArrayList<String> targetVals = new ArrayList<String>(); for (int mappedDur : discr.getPossibleValues()) { targetVals.add(mappedDur + "ms"); } // FastVector attributeDeclarations = data.; // attribute declaration finished data.insertAttributeAt(new Attribute("target", targetVals), data.numAttributes()); for (int i = 0; i < durs.size(); i++) { Instance currInst = data.instance(i); int dur = durs.get(i); // System.out.println(" mapping " + dur + " to " + discr.discretize(dur) + " - bi:" + // data.instance(i).value(data.attribute("breakindex"))); currInst.setValue(data.numAttributes() - 1, discr.discretize(dur) + "ms"); } // Make the last attribute be the class data.setClassIndex(data.numAttributes() - 1); return data; } private Instance createInstance(Instances data, FeatureDefinition fd, FeatureVector fv) { // relevant features + one target Instance currInst = new DenseInstance(data.numAttributes()); currInst.setDataset(data); // read only relevant features for (String attName : this.featureNames) { int featNr = fd.getFeatureIndex(attName); String value = fv.getFeatureAsString(featNr, fd); currInst.setValue(data.attribute(attName), value); } return currInst; } private Instances initData(FeatureDefinition fd) { // this stores the attributes together with allowed values ArrayList<Attribute> attributeDeclarations = new ArrayList<Attribute>(); // first declare all the relevant attributes. // Assume that the feature definition and relevant features of the first // in the list are the same as the others. for (int attribute = 0; attribute < fd.getNumberOfFeatures(); attribute++) { String attName = fd.getFeatureName(attribute); // skip phone if (attName.equals("phone")) { continue; } // ...collect possible values ArrayList<String> attVals = new ArrayList<String>(); for (String value : fd.getPossibleValues(attribute)) { attVals.add(value); } attributeDeclarations.add(new Attribute(attName, attVals)); } // now, create the dataset adding the datapoints return new Instances("pausedurations", attributeDeclarations, 0); } /** * This reads in the features for the symbols in the input (phonemic/automatic) file from a feature stream stored in textual * format. * * @param featureTable * a LineNumberReader from which the feature table is read. * @throws IOException * if the input stream is ill-formed */ private VectorsAndDefinition readFeatureTable(LineNumberReader featureTable) throws IOException { List<FeatureVector> featureVectors = new ArrayList<FeatureVector>(); // read the beginning of the file, containing the feature definition FeatureDefinition fd = new FeatureDefinition(featureTable, false); try { // for later checks, get index of phone identity feature fd.getFeatureIndex("phone"); fd.getFeatureIndex("breakindex"); } catch (IllegalArgumentException e) { throw new IOException( "Unexpected FeatureDefinition: Does not contain the features 'phone' and 'breakindex'."); } // skip section with string representation while (!featureTable.readLine().equals("")) { } // now, read the features line by line String line = ""; while ((line = featureTable.readLine()) != null) { FeatureVector fv; try { fv = fd.toFeatureVector(0, line); } catch (Exception e) { e.printStackTrace(); throw new IOException("Unexpected Input in line " + String.valueOf(featureTable.getLineNumber())); } featureVectors.add(fv); } return new VectorsAndDefinition(featureVectors, fd); } /** * This reads in some pause feature file and returns feature vectors * * * @param basename * basename * @return readFeatureTable(lnr) * @throws IOException * IOException */ private VectorsAndDefinition readFeaturesFor(String basename) throws IOException { FileInputStream fis; // First, test if there is a corresponding .rawmaryxml file in textdir: File fvFile = new File(getProp(FVFILES) + basename + fvExt); if (fvFile.exists()) { fis = new FileInputStream(fvFile); } else { return null; } System.out.println("processing " + getProp(FVFILES) + basename + fvExt); // didn't work ... FeatureFileReader ffr = new FeatureFileReader(); LineNumberReader lnr = new LineNumberReader(new InputStreamReader(fis)); return readFeatureTable(lnr); } public String getName() { return "PauseDurationTrainer"; } @Override public int getProgress() { return 0; } protected void setupHelp() { props2Help = new TreeMap<String, String>(); props2Help.put(FVFILES, "Directory containing the pause feature files."); props2Help.put(LABFILES, "Directory containing label files from which pause durations are taken."); props2Help.put(TRAINEDTREE, "Result of training."); } }