/**
* Produces a shallow copy of this vector.
*
* @return the new vector
*/
public final Object copy() {
FastVector copy = new FastVector(m_Objects.length, m_CapacityIncrement, m_CapacityMultiplier);
copy.m_Size = m_Size;
System.arraycopy(m_Objects, 0, copy.m_Objects, 0, m_Size);
return copy;
}
/**
* Clones the vector and shallow copies all its elements. The elements have to implement the
* Copyable interface.
*
* @return the new vector
*/
public final Object copyElements() {
FastVector copy = new FastVector(m_Objects.length, m_CapacityIncrement, m_CapacityMultiplier);
copy.m_Size = m_Size;
for (int i = 0; i < m_Size; i++) {
copy.m_Objects[i] = ((Copyable) m_Objects[i]).copy();
}
return copy;
}
/**
* Parses a given list of options. Valid options are:
*
* <p>-D <br>
* Turn on debugging output.
*
* <p>-S seed <br>
* Random number seed (default 1).
*
* <p>-B classifierstring <br>
* Classifierstring should contain the full class name of a scheme included for selection followed
* by options to the classifier (required, option should be used once for each classifier).
*
* <p>-X num_folds <br>
* Use cross validation error as the basis for classifier selection. (default 0, is to use error
* on the training data instead)
*
* <p>
*
* @param options the list of options as an array of strings
* @exception Exception if an option is not supported
*/
public void setOptions(String[] options) throws Exception {
setDebug(Utils.getFlag('D', options));
String numFoldsString = Utils.getOption('X', options);
if (numFoldsString.length() != 0) {
setNumFolds(Integer.parseInt(numFoldsString));
} else {
setNumFolds(0);
}
String randomString = Utils.getOption('S', options);
if (randomString.length() != 0) {
setSeed(Integer.parseInt(randomString));
} else {
setSeed(1);
}
// Iterate through the schemes
FastVector classifiers = new FastVector();
while (true) {
String classifierString = Utils.getOption('B', options);
if (classifierString.length() == 0) {
break;
}
String[] classifierSpec = Utils.splitOptions(classifierString);
if (classifierSpec.length == 0) {
throw new Exception("Invalid classifier specification string");
}
String classifierName = classifierSpec[0];
classifierSpec[0] = "";
classifiers.addElement(Classifier.forName(classifierName, classifierSpec));
}
if (classifiers.size() <= 1) {
throw new Exception("At least two classifiers must be specified" + " with the -B option.");
} else {
Classifier[] classifiersArray = new Classifier[classifiers.size()];
for (int i = 0; i < classifiersArray.length; i++) {
classifiersArray[i] = (Classifier) classifiers.elementAt(i);
}
setClassifiers(classifiersArray);
}
}
/** * Create a FastVector containing the set of values found in the given col... */
public FastVector getColValues(Table t, int colIdx) {
HashSet<String> valSet = new HashSet<String>();
for (int r = 0; r < t.rows(); r++) {
String val = (String) t.matrix.getQuick(r, colIdx);
if (val == null) {
System.err.println("\nDEBUG r=" + r + "\tc=" + colIdx + "\tval=" + val);
System.err.println("\nDEBUG r=" + t.rowNames[r] + "\tc=" + t.colNames[colIdx]);
}
// Don't want to include "missing value" as one of the nominal values...
if (val != null) {
if (!val.equals("?")) {
valSet.add(val);
}
}
}
FastVector attVals = new FastVector();
for (Object v : valSet) {
attVals.addElement(v);
}
return (attVals);
}
public void buildClusterer(ArrayList<String> seqDB, double[][] sm) {
seqList = seqDB;
this.setSimMatrix(sm);
Attribute seqString = new Attribute("sequence", (FastVector) null);
FastVector attrInfo = new FastVector();
attrInfo.addElement(seqString);
Instances data = new Instances("data", attrInfo, 0);
for (int i = 0; i < seqList.size(); i++) {
Instance currentInst = new Instance(1);
currentInst.setDataset(data);
currentInst.setValue(0, seqList.get(i));
data.add(currentInst);
}
try {
buildClusterer(data);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* * Create a FastVector containing the set of values found in the given row...
*
* <p>NOTE: As it happens, this function determines the order of the attribute values, an order
* that will percolate throughout wekaMine and influence all subsequent displays.
*
* <p>Originally the valSet was a HashSet and the iteration order of that will depend on the hash
* code for the key, and may seem random. While we would not like to rely on the order of
* attributes, it seems desirable to make the attribute order somehow comprehensible, either sort
* order or insertion order. Insertion order will seem random also because it is determined by the
* arbitrary order of the instances. So it has been changed to a TreeSet which will be ordered by
* the natural ordering of it's elements.
*/
public FastVector getRowValues(Table t, int rowIdx) {
TreeSet<String> valSet = new TreeSet<String>();
for (int c = 0; c < t.cols(); c++) {
String val = (String) t.matrix.getQuick(rowIdx, c);
if (val == null) {
System.err.println("null value in row:" + rowIdx + " col:" + c);
for (int i = 0; i < t.cols(); i++) {
System.err.println("\t" + i + "\t" + t.matrix.getQuick(rowIdx, c));
}
}
// Don't want to include "missing value" as one of the nominal values...
if (!val.equals("?")) {
valSet.add(val);
}
}
FastVector attVals = new FastVector();
for (Object v : valSet) {
attVals.addElement(v);
}
return (attVals);
}
/**
* Returns the next element.
*
* @return the next element to be enumerated
*/
public final Object nextElement() {
Object result = m_Vector.elementAt(m_Counter);
m_Counter++;
if (m_Counter == m_SpecialElement) m_Counter++;
return result;
}
/**
* Tests if there are any more elements to enumerate.
*
* @return true if there are some elements left
*/
public final boolean hasMoreElements() {
return m_Counter < m_Vector.size();
}
/**
* Appends all elements of the supplied vector to this vector.
*
* @param toAppend the FastVector containing elements to append.
*/
public final void appendElements(FastVector toAppend) {
setCapacity(size() + toAppend.size());
System.arraycopy(toAppend.m_Objects, 0, m_Objects, size(), toAppend.size());
m_Size = m_Objects.length;
}
/**
* ************************************************** Convert a table to a set of instances, with
* <b>columns</b> representing individual </b>instances</b> and <b>rows</b> representing
* <b>attributes</b> (e.g. as is common with microarray data)
*/
public Instances tableColsToInstances(Table t, String relationName) {
System.err.print("Converting table cols to instances...");
// Set up attributes, which for colInstances will be the rowNames...
FastVector atts = new FastVector();
ArrayList<Boolean> isNominal = new ArrayList<Boolean>();
ArrayList<FastVector> allAttVals = new ArrayList<FastVector>(); // Save values for later...
System.err.print("creating attributes...");
for (int r = 0; r < t.numRows; r++) {
if (rowIsNumeric(t, r)) {
isNominal.add(false);
atts.addElement(new Attribute(t.rowNames[r]));
allAttVals.add(null); // No enumeration of attribute values.
} else {
// It's nominal... determine the range of values and create a nominal attribute...
isNominal.add(true);
FastVector attVals = getRowValues(t, r);
atts.addElement(new Attribute(t.rowNames[r], attVals));
// Save it for later
allAttVals.add(attVals);
}
}
System.err.print("creating instances...");
// Create Instances object..
Instances data = new Instances(relationName, atts, 0);
data.setRelationName(relationName);
/** ***** CREATE INSTANCES ************* */
// Fill the instances with data...
// For each instance...
for (int c = 0; c < t.numCols; c++) {
double[] vals =
new double[data.numAttributes()]; // Even nominal values are stored as double pointers.
// For each attribute fill in the numeric or attributeValue index...
for (int r = 0; r < t.numRows; r++) {
String val = (String) t.matrix.getQuick(r, c);
if (val == "?") vals[r] = Instance.missingValue();
else if (isNominal.get(r)) {
vals[r] = allAttVals.get(r).indexOf(val);
} else {
vals[r] = Double.parseDouble((String) val);
}
}
// Add the a newly minted instance with those attribute values...
data.add(new Instance(1.0, vals));
}
System.err.print("add feature names...");
/** ***** ADD FEATURE NAMES ************* */
// takes basically zero time... all time is in previous 2 chunks.
if (addInstanceNamesAsFeatures) {
Instances newData = new Instances(data);
newData.insertAttributeAt(new Attribute("ID", (FastVector) null), 0);
int attrIdx = newData.attribute("ID").index(); // Paranoid... should be 0
// We save the instanceNames in a list because it's handy later on...
instanceNames = new ArrayList<String>();
for (int c = 0; c < t.colNames.length; c++) {
instanceNames.add(t.colNames[c]);
newData.instance(c).setValue(attrIdx, t.colNames[c]);
}
data = newData;
}
System.err.println("done.");
return (data);
}
/**
* ************************************************** Convert a table to a set of instances, with
* <b>rows</b> representing individual </b>instances</b> and <b>columns</b> representing
* <b>attributes</b>
*/
public Instances tableRowsToNominalInstances(Table t, String relationName) {
System.err.print("Converting table rows to instances...");
// Set up attributes, which for rowInstances will be the colNames...
FastVector atts = new FastVector();
ArrayList<Boolean> isNominal = new ArrayList<Boolean>();
ArrayList<FastVector> allAttVals = new ArrayList<FastVector>(); // Save values for later...
System.err.print("creating attributes...");
for (int c = 0; c < t.numCols; c++) {
// It's nominal... determine the range of values
isNominal.add(true);
FastVector attVals = getColValues(t, c);
atts.addElement(new Attribute(t.colNames[c], attVals));
// Save it for later
allAttVals.add(attVals);
}
System.err.print("creating instances...");
// Create Instances object..
Instances data = new Instances(relationName, atts, 0);
data.setRelationName(relationName);
// Fill the instances with data...
// For each instance...
for (int r = 0; r < t.numRows; r++) {
double[] vals = new double[data.numAttributes()];
// for each attribute
for (int c = 0; c < t.numCols; c++) {
String val = (String) t.matrix.getQuick(r, c);
if (val == "?") vals[c] = Instance.missingValue();
else if (isNominal.get(c)) {
vals[c] = allAttVals.get(c).indexOf(val);
} else {
vals[c] = Double.parseDouble((String) val);
}
}
// Add the a newly minted instance with those attribute values...
data.add(new Instance(1.0, vals));
}
System.err.print("add feature names...");
if (addInstanceNamesAsFeatures) {
Instances newData = new Instances(data);
newData.insertAttributeAt(new Attribute("ID", (FastVector) null), 0);
int attrIdx = newData.attribute("ID").index(); // Paranoid... should be 0
// We save the instanceNames in a list because it's handy later on...
instanceNames = new ArrayList<String>();
for (int r = 0; r < t.rowNames.length; r++) {
instanceNames.add(t.rowNames[r]);
newData.instance(r).setValue(attrIdx, t.rowNames[r]);
}
data = newData;
}
System.err.println("done.");
return (data);
}
/**
* If we know in advance that the table is numeric, can optimize a lot... For example, on 9803 x
* 294 table, TableFileLoader.readNumeric takes 6s compared to 12s for WekaMine readFromTable.
*/
public static Instances readNumeric(String fileName, String relationName, String delimiter)
throws Exception {
int numAttributes = FileUtils.fastCountLines(fileName) - 1; // -1 exclude heading.
String[] attrNames = new String[numAttributes];
// Read the col headings and figure out the number of columns in the table..
BufferedReader reader = new BufferedReader(new FileReader(fileName), 4194304);
String line = reader.readLine();
String[] instanceNames = parseColNames(line, delimiter);
int numInstances = instanceNames.length;
System.err.print("reading " + numAttributes + " x " + numInstances + " table..");
// Create an array to hold the data as we read it in...
double dataArray[][] = new double[numAttributes][numInstances];
// Populate the matrix with values...
String valToken = "";
try {
int rowIdx = 0;
while ((line = reader.readLine()) != null) {
String[] tokens = line.split(delimiter, -1);
attrNames[rowIdx] = tokens[0].trim();
for (int colIdx = 0; colIdx < (tokens.length - 1); colIdx++) {
valToken = tokens[colIdx + 1];
double value;
if (valToken.equals("null")) {
value = Instance.missingValue();
} else if (valToken.equals("?")) {
value = Instance.missingValue();
} else if (valToken.equals("NA")) {
value = Instance.missingValue();
} else if (valToken.equals("")) {
value = Instance.missingValue();
// }else value = DoubleParser.lightningParse(valToken); // faster double parser with
// MANY assumptions
} else value = Double.parseDouble(valToken);
dataArray[rowIdx][colIdx] = value;
}
rowIdx++;
}
} catch (NumberFormatException e) {
System.err.println(e.toString());
System.err.println("Parsing line: " + line);
System.err.println("Parsing token: " + valToken);
}
// Set up attributes, which for colInstances will be the rowNames...
FastVector atts = new FastVector();
for (int a = 0; a < numAttributes; a++) {
atts.addElement(new Attribute(attrNames[a]));
}
// Create Instances object..
Instances data = new Instances(relationName, atts, 0);
data.setRelationName(relationName);
System.err.print("creating instances..");
// System.err.println("DEBUG: numAttributes "+numAttributes);
/** ***** CREATE INSTANCES ************* */
// Fill the instances with data...
// For each instance...
for (int c = 0; c < numInstances; c++) {
double[] vals =
new double[data.numAttributes()]; // Even nominal values are stored as double pointers.
for (int r = 0; r < numAttributes; r++) {
double val = dataArray[r][c];
vals[r] = val;
}
// Add the a newly minted instance with those attribute values...
data.add(new Instance(1.0, vals));
}
// System.err.println("DEBUG: data.numInstances: "+data.numInstances());
// System.err.println("DEBUG: data.numAttributes: "+data.numAttributes());
// System.err.println("DEBUG: data.relationNAme"+data.relationName());
System.err.print("add feature names..");
/** ***** ADD FEATURE NAMES ************* */
// takes basically zero time... all time is in previous 2 chunks.
Instances newData = new Instances(data);
newData.insertAttributeAt(new Attribute("ID", (FastVector) null), 0);
int attrIdx = newData.attribute("ID").index(); // Paranoid... should be 0
for (int c = 0; c < numInstances; c++) {
newData.instance(c).setValue(attrIdx, instanceNames[c]);
}
data = newData;
// System.err.println("DEBUG: data.numInstances: "+data.numInstances());
// System.err.println("DEBUG: data.numAttributes: "+data.numAttributes());
return (data);
}
