private static Dictionary <string, DataRecord[]> SplitDataByClassification(DataWarehouse WH)
{
Dictionary <string, DataRecord[]> d = new Dictionary <string, DataRecord[]>();
string[] classifications = WH.GetRecords().Select(r => r.GetAttributeValue(WH.ClassificationAttribute)).Distinct().ToArray();
foreach (string classification in classifications)
{
d.Add(classification, WH.GetRecords().Where(r => r.GetAttributeValue(WH.ClassificationAttribute) == classification).ToArray());
}
return(d);
}
private static Dictionary <string, DataRecord> GetAverageClassValues(DataWarehouse WH)
{
DataRecord[] records = WH.GetRecords();
string[] classifications = records.Select(r => r.GetAttributeValue(WH.ClassificationAttribute)).Distinct().ToArray();
ConcurrentDictionary <string, DataRecord> averageDataRecords = new ConcurrentDictionary <string, DataRecord>();
Parallel.ForEach(classifications, (classification) =>
{
DataRecord averageRecord = new DataRecord();
IEnumerable <DataRecord> targetRecords = records.Where(r => r.GetAttributeValue(WH.ClassificationAttribute) == classification);
foreach (string attribute in WH.Attributes)
{
if (attribute != WH.ClassificationAttribute && attribute != WH.IDAttribute)
{
decimal total = 0;
foreach (DataRecord r in targetRecords)
{
total += decimal.Parse(r.GetAttributeValue(attribute));
}
averageRecord.AddOrUpdateValue(attribute, (total / targetRecords.Count()).ToString());
}
}
averageDataRecords.TryAdd(classification, averageRecord);
});
return(new Dictionary <string, DataRecord>(averageDataRecords));
}
public Classification[] ThreadedClassify(DataWarehouse Warehouse)
{
ConcurrentQueue <Classification> classifications = new ConcurrentQueue <Classification>();
Parallel.ForEach(Warehouse.GetRecords(), (r) =>
{
foreach (Classification c in Classify(r))
{
classifications.Enqueue(c);
}
});
return(classifications.ToArray());
}
protected virtual string[] OutputImage(string outputFilePath, DataWarehouse WH, DataRecord Record = null, double power = 2)
{
DataRecord[] records = WH.GetRecords();
Dictionary <string, DataRecord> averageClassValues = GetAverageClassValues(WH);
string[] targetAttributeValues = averageClassValues.Keys.ToArray();
double[] distancesFromAverageClasses = new double[targetAttributeValues.Length];
int count = 0;
foreach (KeyValuePair <string, DataRecord> kv in averageClassValues)
{
distancesFromAverageClasses[count++] = GetDistanceBetweenRecords(Record, kv.Value, WH.IDAttribute, WH.ClassificationAttribute, power);
}
Chart chart = new Chart();
chart.Titles.Add(distanceName + " distance from an average entity of each classification");
Series serie = new Series
{
Name = "serie"
};
chart.Series.Add(serie);
chart.Series["serie"].Points.DataBindXY(targetAttributeValues, distancesFromAverageClasses);
chart.Series["serie"].ChartType = SeriesChartType.Radar;
chart.Series["serie"]["RadarDrawingStyle"] = "Area";
chart.Series["serie"]["AreaDrawingStyle"] = "Polygon";
chart.Series["serie"]["CircularLabelsStyle"] = "Horizontal";
ChartArea area = new ChartArea
{
Name = "area"
};
chart.ChartAreas.Add(area);
chart.SaveImage(outputFilePath + ".png", ChartImageFormat.Png);
return(new string[] { outputFilePath + ".png" });
}
static void UserInteraction()
{
bool validIDSupplied = false;
int targetID = -1;
do
{
Console.ForegroundColor = ConsoleColor.Black;
Console.BackgroundColor = ConsoleColor.Yellow;
Console.WriteLine("Please enter an ID, or press return to classify latest entry.");
Console.ResetColor();
string input = Console.ReadLine();
if (input == "")
{
break;
}
else
{
if (int.TryParse(input, out targetID))
{
validIDSupplied = targetID < warehouse.GetRecords().Count() && targetID >= 0;
}
if (!validIDSupplied)
{
Console.ForegroundColor = ConsoleColor.Black;
Console.BackgroundColor = ConsoleColor.Red;
Console.WriteLine("Invalid ID supplied.");
Console.ResetColor();
}
}
}while (!validIDSupplied);
Console.Clear();
DataWarehouse translatedWarehouse = translator.TranslateWarehouse(warehouse);
translator.SaveTranslatorToFile();
DataRecord targetRecord = null;
if (targetID > -1)
{
targetRecord = warehouse.GetRecord(targetID);
}
else
{
targetRecord = warehouse.GetLatestRecord();
}
List <string> classificationStrings = new List <string>();
foreach (Classification c in cm.ThreadedClassify(targetRecord))
{
string s = c.ToString();
classificationStrings.Add(s);
Console.WriteLine(s);
Console.WriteLine();
}
DataRecord targetRecordTranslated = translator.TranslateRecord(targetRecord);
ConcurrentBag <string> visualizationBag = new ConcurrentBag <string>();
if (Visualizers.Count > 0)
{
if (!Directory.Exists(VisualizerOutputDir + "\\" + translatedWarehouse.FileName + "\\" + targetRecord.ID))
{
Directory.CreateDirectory(VisualizerOutputDir + "\\" + translatedWarehouse.FileName + "\\" + targetRecord.ID);
}
Parallel.ForEach(Visualizers, (v) =>
{
string[] paths = v.Visualize(VisualizerOutputDir + "\\" + translatedWarehouse.FileName + "\\" + targetRecord.ID + "\\" + v.GetType().Name.ToString(),
translatedWarehouse,
targetRecordTranslated);
foreach (string path in paths)
{
visualizationBag.Add(path);
}
});
}
ReportGenerator.GenerateReport(VisualizerOutputDir + "\\" + translatedWarehouse.FileName + "\\" + targetRecord.ID + "\\Report.html",
targetRecord.ID,
classificationStrings.ToArray(),
visualizationBag.ToArray());
Process.Start(VisualizerOutputDir + "\\" + translatedWarehouse.FileName + "\\" + targetRecord.ID + "\\Report.html");
}
