private void button2_Click(object sender, EventArgs e)
{
object selectedValue = itemsource[1];
if (selectedValue != null)
{
Type selectedType = (Type)selectedValue;
currFeatDisplay = Activator.CreateInstance(selectedType) as IFeatureDisplay;
Type currFeatType = featTypeByDisplay[selectedType];
selitem = extractorsByFeatType[currFeatType];
}
object selvalue = selitem[0];
if (selvalue != null)
{
Type selType = (Type)selvalue;
currExtractor = Activator.CreateInstance(selType) as IFeatureExtractor;
}
if (img == null)
{
MessageBox.Show("You must select an image!", "Displaying error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
pictureBox2.Image = img.Clone() as Bitmap;
Graphics g = Graphics.FromImage(pictureBox2.Image);
{
var features = currExtractor.ExtractFeatures(img);
currFeatDisplay.Show(features, g);
button3.Visible = true;
}
}
private void ExtractTrainingSetFromFolder()
{
ISnippetParser fsp = new FolderSnippetParser();
List <CodeSnippet> snippets = fsp.ExtractLabeledCodeSnippets("manual");
Encoding utf8 = Encoding.GetEncoding("UTF-8", new EncoderReplacementFallback(string.Empty), new DecoderExceptionFallback());
using (StreamWriter w = new StreamWriter("cp-training-30k.csv", false, utf8))
{
w.WriteLine("Language,Snippet");
Parallel.ForEach(snippets, s =>
{
StringBuilder sb = new StringBuilder();
foreach (string f in fe.ExtractFeatures(s.Snippet))
{
// The lines can't be longer than 32k or they'll wrap for some reason
if (sb.Length < 32700)
{
sb.Append(f);
sb.Append(" ");
}
}
lock (w)
{
string snippet = sb.ToString().Replace(",", "");
// We don't want to train off of small snippets
if (snippet.Length >= 256)
{
w.WriteLine(s.Language.ToLower() + "," + snippet);
}
}
});
}
}
private void display_minutiae_features()
{
if (img == null)
{
return;
}
else
{
pictureBox_fingerprint.Image = img.Clone() as Bitmap;
Graphics g = Graphics.FromImage(pictureBox_fingerprint.Image);
try
{
var features = currExtractor.ExtractFeatures(img);
currFeatDisplay.Show(features, g);
}
catch (Exception exc)
{
MessageBox.Show(exc.Message, "Displaying error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
protected override IEnumerable <FeatureVectorList> ExtractFeatureVectors(Prediction prediction, bool training, DateTime start, DateTime end)
{
Dictionary <TimeSliceFeature, string> featureId = new Dictionary <TimeSliceFeature, string>();
foreach (Feature feature in Features.Where(f => f.EnumType == typeof(TimeSliceFeature)))
{
featureId.Add((TimeSliceFeature)feature.EnumValue, feature.Id);
}
List <TimeSliceFeature> threeHourIntervals = new List <TimeSliceFeature>(new TimeSliceFeature[] { TimeSliceFeature.LateNight, TimeSliceFeature.EarlyMorning, TimeSliceFeature.Morning, TimeSliceFeature.MidMorning, TimeSliceFeature.Afternoon, TimeSliceFeature.MidAfternoon, TimeSliceFeature.Evening, TimeSliceFeature.Night });
int processorCount = Configuration.ProcessorCount;
Configuration.ProcessorCount = 1; // all sub-threads (e.g., those in FeatureBasedDCM) should use 1 core, since we're multi-threading here
Set <Thread> threads = new Set <Thread>(processorCount);
long firstSlice = (long)((training ? prediction.Model.TrainingStart.Ticks : prediction.PredictionStartTime.Ticks) / _timeSliceTicks);
long lastSlice = (long)((training ? prediction.Model.TrainingEnd.Ticks : prediction.PredictionEndTime.Ticks) / _timeSliceTicks);
long ticksPerHour = new TimeSpan(1, 0, 0).Ticks;
List <FeatureVectorList> completeFeatureVectorLists = new List <FeatureVectorList>();
List <FeatureVectorList> incompleteFeatureVectorLists = new List <FeatureVectorList>();
AutoResetEvent emitCompleteFeatureVectorLists = new AutoResetEvent(false);
IFeatureExtractor externalFeatureExtractor = InitializeExternalFeatureExtractor(typeof(TimeSliceDCM));
for (int i = 0; i < processorCount; ++i)
{
Thread t = new Thread(new ParameterizedThreadStart(core =>
{
for (long slice = firstSlice + (int)core; slice <= lastSlice; slice += processorCount)
{
Console.Out.WriteLine("Processing slice " + (slice - firstSlice + 1) + " of " + (lastSlice - firstSlice + 1));
DateTime sliceStart = new DateTime(slice * _timeSliceTicks);
DateTime sliceEnd = sliceStart.Add(new TimeSpan(_timeSliceTicks - 1));
DateTime sliceMid = new DateTime((sliceStart.Ticks + sliceEnd.Ticks) / 2L);
#region get interval features that are true for all points in the current slice
Dictionary <NumericFeature, int> threeHourIntervalFeatureValue = new Dictionary <NumericFeature, int>();
int startingThreeHourInterval = sliceStart.Hour / 3; // which 3-hour interval does the current slice start in?
int threeHourIntervalsTouched = (int)(((sliceEnd.Ticks - sliceStart.Ticks) / ticksPerHour) / 3) + 1; // how many 3-hour intervals does the current slice touch?
int endingThreeHourInterval = startingThreeHourInterval + threeHourIntervalsTouched - 1; // which 3-hour interval does the current slice end in?
for (int k = 0; k < threeHourIntervals.Count; ++k)
{
TimeSliceFeature threeHourInterval = threeHourIntervals[k];
string id;
if (featureId.TryGetValue(threeHourInterval, out id)) // if the current model uses the current 3-hour interval as a feature
{
bool covered = false;
for (int interval = startingThreeHourInterval; !covered && interval <= endingThreeHourInterval; ++interval)
{
if (interval % 8 == k)
{
covered = true;
}
}
threeHourIntervalFeatureValue.Add(IdNumericFeature[id], covered ? 1 : 0);
}
}
#endregion
#region extract feature vectors
foreach (FeatureVectorList featureVectors in base.ExtractFeatureVectors(prediction, training, sliceStart, sliceEnd))
{
if (!featureVectors.Complete)
{
throw new Exception("Incomplete feature vectors received from base class extractor");
}
Console.Out.WriteLine("Extracting " + featureId.Count + " time slice features for " + featureVectors.Count + " points.");
foreach (FeatureVector featureVector in featureVectors)
{
Point point = featureVector.DerivedFrom as Point;
if (point.Time == DateTime.MinValue)
{
point.Time = sliceMid;
}
else if ((long)(point.Time.Ticks / _timeSliceTicks) != slice)
{
throw new Exception("Point should not be in slice: " + point);
}
foreach (LAIR.MachineLearning.NumericFeature threeHourIntervalFeature in threeHourIntervalFeatureValue.Keys)
{
featureVector.Add(threeHourIntervalFeature, threeHourIntervalFeatureValue[threeHourIntervalFeature]);
}
double percentThroughPeriod = (slice % _periodTimeSlices) / (double)(_periodTimeSlices - 1);
double radians = 2 * Math.PI * percentThroughPeriod;
foreach (TimeSliceFeature feature in featureId.Keys)
{
if (feature == TimeSliceFeature.CosinePeriodPosition)
{
featureVector.Add(IdNumericFeature[featureId[feature]], Math.Cos(radians));
}
else if (feature == TimeSliceFeature.SinePeriodPosition)
{
featureVector.Add(IdNumericFeature[featureId[feature]], Math.Sin(radians));
}
}
}
if (externalFeatureExtractor == null)
{
lock (completeFeatureVectorLists)
{
completeFeatureVectorLists.Add(featureVectors);
emitCompleteFeatureVectorLists.Set();
}
}
else
{
foreach (FeatureVectorList externalFeatureVectors in externalFeatureExtractor.ExtractFeatures(prediction, featureVectors, training, sliceStart, sliceEnd, false))
{
if (externalFeatureVectors.Complete)
{
lock (completeFeatureVectorLists)
{
completeFeatureVectorLists.Add(externalFeatureVectors);
emitCompleteFeatureVectorLists.Set();
}
}
else
{
lock (incompleteFeatureVectorLists)
incompleteFeatureVectorLists.Add(externalFeatureVectors);
}
}
}
}
#endregion
}
lock (threads)
threads.Remove(Thread.CurrentThread);
emitCompleteFeatureVectorLists.Set();
}));
lock (threads) { threads.Add(t); }
t.Start(i);
}
while (emitCompleteFeatureVectorLists.WaitOne())
{
lock (completeFeatureVectorLists)
{
foreach (FeatureVectorList completeFeatureVectors in completeFeatureVectorLists)
{
yield return(completeFeatureVectors);
}
completeFeatureVectorLists.Clear();
}
lock (threads)
if (threads.Count == 0)
{
break;
}
}
// emit any remaining completed vectors, which might have arrived just before the last thread was removed (breaking out of the loop above)
foreach (FeatureVectorList completeFeatureVectors in completeFeatureVectorLists)
{
yield return(completeFeatureVectors);
}
completeFeatureVectorLists.Clear();
Configuration.ProcessorCount = processorCount; // reset system-wide processor count since we're done with threads here
foreach (FeatureVectorList incompleteFeatureVectors in incompleteFeatureVectorLists)
{
foreach (FeatureVectorList externalFeatureVectors in externalFeatureExtractor.ExtractFeatures(prediction, incompleteFeatureVectors, training, start, end, true))
{
yield return(externalFeatureVectors);
}
}
}
