public WekaInvoke(string trainfile)
{
nb = new T();
//nb = new new weka.classifiers.lazy.IBk();
//nb = new weka.classifiers.bayes.NaiveBayes();
weka.core.converters.ConverterUtils.DataSource ds = new weka.core.converters.ConverterUtils.DataSource(trainfile);
trainset = ds.getDataSet();
structure = ds.getStructure();
if (trainset.classIndex() == -1)
{
trainset.setClassIndex(trainset.numAttributes() - 1);
}
for (int i = 0; i < trainset.numInstances(); ++i)
{
//Console.WriteLine(trainset.instance(i).AttributeName());
}
nb.buildClassifier(trainset);
attributes = ListAttributes();
classifications = ListClassifications();
}
public int classify(Bitmap currentImage)
{
try {
currentImage.Save(OutputDir + "Results/temp.png", System.Drawing.Imaging.ImageFormat.Png);
// Create folder
System.IO.Directory.CreateDirectory(OutputDir + "Results/");
StreamWriter output = new StreamWriter(OutputDir + "Results/" + "temp.arff");
output.Write("@relation 'galaxy'\n");
output.Write("@attribute class real\n");
output.Write("@attribute colorF real\n");
output.Write("@attribute bulgeF real\n");
output.Write("@attribute constF real\n");
for (int i = 0; i < sv * 3; i++) {
output.Write("@attribute " + i + " real\n");
}
output.Write("@data\n");
Bitmap tempImage = getImage(OutputDir + "Results/temp.png",
imageScaleSize);
for (int i = 0; i < imageScaleSize; i++) {
for (int j = 0; j < imageScaleSize; j++) {
int pixelColor = tempImage.GetPixel(i, j).ToArgb();
int[] rgb = new int[3];
rgb[0] += ((pixelColor & 0x00ff0000) >> 16);
rgb[1] += ((pixelColor & 0x0000ff00) >> 8);
rgb[2] += (pixelColor & 0x000000ff);
dataRed.SetElement(galaxyData.Count() - 1, i * imageScaleSize + j,
rgb[0]);
dataGreen.SetElement(galaxyData.Count() - 1,
i * imageScaleSize + j, rgb[1]);
dataBlue.SetElement(galaxyData.Count() - 1, i * imageScaleSize + j,
rgb[2]);
}
}
var redWorker = System.Threading.Tasks.Task.Factory.StartNew(() => svdR = new SingularValueDecomposition(dataRed));
var greenWorker = System.Threading.Tasks.Task.Factory.StartNew(() => svdG = new SingularValueDecomposition(dataGreen));
var blueWorker = System.Threading.Tasks.Task.Factory.StartNew(() => svdB = new SingularValueDecomposition(dataBlue));
System.Threading.Tasks.Task.WaitAll(redWorker, greenWorker, blueWorker);
GeneralMatrix rU = svdR.GetU();
GeneralMatrix gU = svdG.GetU();
GeneralMatrix bU = svdB.GetU();
rU = GetSVs(rU, sv);
gU = GetSVs(gU, sv);
bU = GetSVs(bU, sv);
float colorFactor = (GetColor(tempImage)[0] / GetColor(tempImage)[2]);
float centralBulgeFactor = getCentralBulge(tempImage);
float consistencyFactor = GetConsistency(tempImage);
output.Write(galaxyData[galaxyData.Count() - 1][1] + ", ");
output.Write(colorFactor + ", ");
output.Write(centralBulgeFactor + ", ");
output.Write(consistencyFactor + ", ");
// output data (r,g,b)
for (int i = 0; i < rU.ColumnDimension; i++) {
output.Write(rU.GetElement(galaxyData.Count() - 1, i) + ", ");
output.Write(gU.GetElement(galaxyData.Count() - 1, i) + ", ");
if (i == rU.ColumnDimension - 1) {
output.Write(bU.GetElement(galaxyData.Count() - 1, i) + "\n");
}
else {
output.Write(bU.GetElement(galaxyData.Count() - 1, i) + ", ");
}
}
output.Flush();
output.Close();
output.Dispose();
weka.core.converters.ConverterUtils.DataSource source = new weka.core.converters.ConverterUtils.DataSource(OutputDir + "Results/temp.arff");
weka.core.Instances test = source.getDataSet();
test.setClassIndex(0);
int classPrediction = (int)Math.Round(fc.classifyInstance(test.instance(0)));
if (classPrediction < -6) {
classPrediction = -6;
}
else if (classPrediction > 11) {
classPrediction = 11;
}
return classPrediction;
}
catch (Exception ex) {
Console.Write(ex.ToString());
}
return -99;
}
//public object Clone() {
// MemoryStream ms = new MemoryStream(500000000);
// System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf =
// new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter(null,
// new System.Runtime.Serialization.StreamingContext(System.Runtime.Serialization.StreamingContextStates.Clone));
// bf.Serialize(ms, this);
// ms.Seek(0, SeekOrigin.Begin);
// object obj = bf.Deserialize(ms);
// ms.Close();
// return obj;
//}
public void train(bool LoadingFromFile)
{
if (!LoadingFromFile) {
DisplayMessage("Begin training on Efigi galaxies...");
Console.Write("Begin training on Efigi galaxies...");
}
else {
DisplayImage(0);
DisplayMessage("Load from file...");
Console.Write("Load from file...");
frV = new GeneralMatrix(ReadFVMatrix(0));
fgV = new GeneralMatrix(ReadFVMatrix(1));
fbV = new GeneralMatrix(ReadFVMatrix(2));
}
weka.classifiers.trees.M5P tree = new weka.classifiers.trees.M5P();
String[] options = new String[1];
weka.core.converters.ConverterUtils.DataSource source = new weka.core.converters.ConverterUtils.DataSource(OutputDir + "Results/" + "resultsGalaxy.arff");
data = source.getDataSet();
if (data == null) {
DisplayMessage("Cannot load from file.");
throw new Exception("Arff File not valid");
}
data.setClassIndex(0);
tree.buildClassifier(data);
StreamWriter output = new StreamWriter(OutputDir + "Results/" + "classification.txt");
rmse = 0.0;
int classifiedCount = 0;
weka.filters.unsupervised.attribute.Remove rm = new weka.filters.unsupervised.attribute.Remove();
rm.setInputFormat(data);
fc = new FilteredClassifier();
fc.setFilter(rm);
fc.setClassifier(tree);
for (int i = 0; i < data.numInstances(); i++) {
int classPrediction = (int)Math.Round(fc.classifyInstance(data.instance(i)));
if (classPrediction < -6) {
classPrediction = -6;
}
else if (classPrediction > 11) {
classPrediction = 11;
}
int actualClass = (int)Math.Round(data.instance(i).classValue());
int error = Math.Abs(classPrediction - actualClass);
rmse += error * error;
classifiedCount++;
output.WriteLine("\n" + classPrediction + ", " + error);
if (i % 10 == 0 && !LoadingFromFile)
DisplayImage(i);
}
rmse = Math.Sqrt(rmse / classifiedCount);
output.WriteLine("\nRMSE: " + rmse);
DisplayMessage("RMSE: " + rmse);
output.Flush();
output.Close();
output.Dispose();
readyToClassify = true;
Console.WriteLine("Finished training on Efigi galaxies; RMSE: " + rmse.ToString());
}
// file path to a folder of galaxy images to classify
public void classify(String filePath)
{
ThreadPool.QueueUserWorkItem((t) => {
try {
Console.Write("Processing multiple images");
string[] images = System.IO.Directory.GetFiles(filePath).Where((string s) => {
return s.Trim().ToUpper().EndsWith(".JPG") || s.Trim().ToUpper().EndsWith(".PNG") || s.Trim().ToUpper().EndsWith(".PNG");
}).ToArray();
Console.Write("Num of galaxies to classify: " + images.Count());
DisplayMessage("Number of galaxies to classify: " + images.Count());
// sample the images for svd
// Create folder
System.IO.Directory.CreateDirectory(OutputDir + "Results/");
StreamWriter output = new StreamWriter(OutputDir + "Results/" + "temp.arff");
output.Write("@relation 'galaxy'\n");
output.Write("@attribute class real\n");
output.Write("@attribute colorF real\n");
output.Write("@attribute bulgeF real\n");
output.Write("@attribute constF real\n");
for (int i = 0; i < sv * 3; i++) {
output.Write("@attribute " + i + " real\n");
}
output.Write("@data\n");
int groupCount = (int)Math.Ceiling(((decimal)images.Count()) / (decimal)1000.0);
for (int i = 0; i < groupCount; i++) {
DisplayMessage("Classifying group " + (i + 1).ToString() + " of " + (groupCount).ToString() + " - " + (100 * i / groupCount).ToString() + "%");
int toTake = Math.Min(1000, images.Length - i * 1000);
ClassifyGroup(images.Skip(i * 1000).Take(toTake).ToArray(), filePath, output, i);
}
output.Flush();
output.Close();
output.Dispose();
Console.WriteLine("Finished creating testing arff file...");
DisplayMessage("Finished creating testing arff file...");
// create the list of image[] indices and their associated Equitorial Coords.
List<Datastructures.Coordinate> coords = new List<Datastructures.Coordinate>();
//parse the file names and intialize coords arraylist
for (int i = 0; i < images.Count(); i++) {
var matches = Regex.Matches(images[i].ToLower(), "[0-9]+(\\.[0-9]+)", RegexOptions.IgnoreCase | RegexOptions.Compiled);
if (matches.Count > 0) {
Console.Write(images[i]);
Console.Write(matches[0].Groups[0].Value);
Console.WriteLine(matches[1].Groups[0].Value);
coords.Add(new Datastructures.Coordinate(Convert.ToDouble(matches[0].Groups[0].Value), Convert.ToDouble(matches[1].Groups[0].Value)));
}
}
Console.WriteLine("Start classifiying the images in " + filePath);
DisplayMessage("Start classifying the images in " + filePath);
StreamWriter outputClasses = new StreamWriter(OutputDir + "Results/" + "Final Classifications.txt");
outputClasses.Write("RA, DEC, Classification" + "\n");
weka.core.converters.ConverterUtils.DataSource source = new weka.core.converters.ConverterUtils.DataSource(OutputDir + "Results/temp.arff");
weka.core.Instances tests = source.getDataSet();
tests.setClassIndex(0);
for (int i = 0; i < tests.numInstances(); i++) {
int classPrediction = (int)Math.Round(fc.classifyInstance(tests.instance(i)));
if (classPrediction < -6) {
classPrediction = -6;
}
else if (classPrediction > 11) {
classPrediction = 11;
}
outputClasses.Write(coords[i].getRA() + ", " + coords[i].getDec() + ", " + classPrediction + "\n");
if (!System.IO.Directory.Exists(OutputDir + "Results/SampleOutput/"))
System.IO.Directory.CreateDirectory(OutputDir + "Results/SampleOutput/");
if (!System.IO.Directory.Exists(OutputDir + "Results/SampleOutput/Class" + (classPrediction.ToString() + "/")))
System.IO.Directory.CreateDirectory(OutputDir + "Results/SampleOutput/Class" + (classPrediction.ToString()) + "/");
new Bitmap(images[i]).Save(OutputDir + "Results/SampleOutput/Class" + classPrediction.ToString() + "/" + images[i].Substring(images[i].IndexOf('@')));
}
outputClasses.Flush();
outputClasses.Close();
outputClasses.Dispose();
Console.WriteLine("Finished classifiying in " + filePath);
DisplayMessage("Finished classifying in " + filePath);
}
catch (Exception ex) {
Console.WriteLine(ex.ToString());
}
}, null);
}
