private bool OnSetPredictedServiceItem(Entity entity, ClassificationResult result)
{
////TODO #CRM-34721 Devide into 2 packages: for Customer Center and Service Enterprise
if (entity.FindEntityColumnValue("ServicePactId") == null)
{
return(true);
}
UserConnection userConnection = Get <UserConnection>("UserConnection");
Guid.TryParse(result.Value, out var serviceItemId);
Guid servicePactId = entity.GetTypedColumnValue <Guid>("ServicePactId");
var select = (Select) new Select(userConnection)
.Column(Column.Const(1))
.From("ServiceInServicePact").As("sp")
.InnerJoin("ServiceStatus").As("ss").On("sp", "StatusId").IsEqual("ss", "Id")
.Where("sp", "ServiceItemId").IsEqual(Column.Parameter(serviceItemId, "Guid"))
.And("sp", "ServicePactId").IsEqual(Column.Parameter(servicePactId, "Guid"))
.And("ss", "Active").IsEqual(Column.Parameter(true, "Boolean"));
try {
return(select.ExecuteScalar <int>() > 0);
} catch (Exception e) {
return(false);
}
}
public double CrossValidate()
{
ExampleSet v_Set; // validation set
//Logging.Info("Retrieving validation set");
v_Set = this.m_problem.ValidationSet;
int numExample = v_Set.Examples.Count;
int numCorrect = 0;
//Logging.Info("Cross Validating on validation set");
foreach (Example example in v_Set.Examples)
{
ClassificationResult result = new ClassificationResult();
if (this.PredictText(example) == example.Label.Id)
{
numCorrect++;
}
}
double correctRatio = 1.0 * numCorrect / numExample;
Logger.Info(string.Format("Correct ratio: {0}", correctRatio));
return(correctRatio);
}
private ClassifierResult ComputeResult(string text, Document document, string documentPath, ClassifierDocumentType[] documentTypes, int evidencePage)
{
// example of unsuccessful classification
if (documentTypes == null || !documentTypes.Any() || document.Pages.Length <= evidencePage)
{
return(null);
}
// take first word from the evidence page in the document and consider it as evidence for the classification
var firstWord = document.Pages[evidencePage].Sections[0].WordGroups[0].Words[0];
var firstWordValueToken = new ResultsValueTokens(0, (float)document.Pages[evidencePage].Size.Width, (float)document.Pages[evidencePage].Size.Height, new[] { firstWord.Box });
// return first document type, with evidecing based on the first word in the document
var classificationResult = new ClassificationResult(
// consider the first document type requested
documentTypes.First().DocumentTypeId,
// fill in document id from the Document Object Model information
document.DocumentId,
// simulate a 85% confidence
0.85f,
// take OCR confidence of the words used for evidencing
firstWord.OcrConfidence,
// build the evidencing information
new ResultsContentReference(firstWord.IndexInText, firstWord.Text.Length, new[] { firstWordValueToken }),
// consider the classification applying to the entire document (all pages)
new ResultsDocumentBounds(document.Pages.Length, document.Length));
return(new ClassifierResult
{
Classifications = new[] { classificationResult }
});
}
public ClassificationResult ClassifyData(string text)
{
var result = new ClassificationResult { Text = text };
var stopWords = Helpers.GetStopWords();
foreach (var token in new Document(text))
{
if (stopWords.Contains(token))
{
continue;
}
var positiveCount = _positiveCorpus.GetTokenCount(token);
var negativeCount = _negativeCorpus.GetTokenCount(token);
var tokenProbability = calculateProbability(positiveCount, _positiveCorpus.EntryCount, negativeCount, _negativeCorpus.EntryCount);
recordProbability(tokenProbability);
result.TokenProbabilities.Add(new TokenProbability
{
Token = token,
Probability = tokenProbability,
PositiveTotal = _positiveCorpus.EntryCount,
PositiveMatches = positiveCount,
NegativeTotal = _negativeCorpus.EntryCount,
NegativeMatches = negativeCount,
Sentiment = calculateSentiment(tokenProbability)
});
}
result.OverallProbability = combineProbabilities();
result.Sentiment = calculateSentiment(result.OverallProbability);
return result;
}
public void ClassifyNearestNeighbour()
{
foreach (var testObject in _testSet.Objects)
{
float finalValue = 0f;
bool first = true;
var result = new ClassificationResult {
Object = testObject
};
foreach (var trainingObject in _trainingSet.Objects)
{
float tempValue = 0f;
for (int i = 0; i < testObject.FeaturesNumber; i++)
{
tempValue += (float)Math.Pow(testObject.Features[i] - trainingObject.Features[i], 2);
}
tempValue = (float)Math.Sqrt(tempValue);
if (first || tempValue < finalValue)
{
finalValue = tempValue;
result.AssignedClassName = trainingObject.ClassName;
first = false;
}
}
NearestNeighbourResult.ClassificationResults.Add(result);
}
}
public void ClassifyNearesMean()
{
Dictionary <string, float[]> classMeans = CountClassMeans();
foreach (var testObject in _testSet.Objects)
{
var result = new ClassificationResult {
Object = testObject
};
float finalValue = 0f;
foreach (var classMean in classMeans)
{
float tempValue = 0f;
var currentMean = classMean.Value;
for (int i = 0; i < testObject.FeaturesNumber; i++)
{
tempValue += (float)Math.Pow(testObject.Features[i] - currentMean[i], 2);
}
tempValue = (float)Math.Sqrt(tempValue);
if (finalValue == 0f || tempValue < finalValue)
{
finalValue = tempValue;
result.AssignedClassName = classMean.Key;
}
}
NearestMeanResult.ClassificationResults.Add(result);
}
}
/// <summary>
/// Saves the predictions and updates column value if prediction is highly significant.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="results">The results.</param>
/// <param name="targetColumnName">Name of the target column.</param>
/// <param name="valueSelectorFunc">Function for select value from prediction list to be setted in target field.
/// If <c>null</c> - high significance value will be selected.</param>
protected virtual void SavePredictions(Entity entity, List <ClassificationResult> results,
string targetColumnName,
Func <IEnumerable <ClassificationResult>, ClassificationResult> valueSelectorFunc)
{
var connectionArg = new ConstructorArgument("userConnection", _userConnection);
var saver = ClassFactory.Get <MLPredictionSaver>(connectionArg);
saver.SavePrediction(ModelId, ModelInstanceUId, entity.PrimaryColumnValue, results);
ClassificationResult highSignificanceValue = null;
if (valueSelectorFunc != null)
{
highSignificanceValue = valueSelectorFunc(results);
}
else
{
highSignificanceValue = results.FirstOrDefault(result => result.Significance == HighSignificance);
}
if (highSignificanceValue == null)
{
_log.InfoFormat("No significant value detected for '{0}' with record id '{1}'",
entity.Schema.Name, entity.PrimaryColumnValue);
return;
}
_log.InfoFormat("Saving significant value '{2}' for '{0}' with record id '{1}'",
entity.Schema.Name, entity.PrimaryColumnValue, highSignificanceValue.Value);
EntitySchemaColumn targetColumn = entity.Schema.GetSchemaColumnByPath(targetColumnName);
entity.SetColumnValue(targetColumn.ColumnValueName, new Guid(highSignificanceValue.Value));
entity.Save(false);
}
public double CrossValidate(TextClassificationProblem problem)
{
ExampleSet v_Set; // validation set
//Logging.Info("Retrieving validation set");
v_Set = problem.ValidationSet;
int numExample = v_Set.Examples.Count;
int numCorrect = 0;
//Logging.Info("Cross Validating on validation set");
foreach (TextExample example in v_Set.Examples)
{
ClassificationResult result = new ClassificationResult();
this.Predict(problem, example, ref result);
if (result.Vnb == example.Label.Name)
{
numCorrect++;
}
}
double correctRatio = 1.0 * numCorrect / numExample;
Logger.Info(string.Format("Correct ratio: {0}", correctRatio));
return(correctRatio);
}
private async Task <ClassificationResult> DoMlNetClassifierAction(IFormFile file)
{
var client = _httpClientFactory.CreateClient(HttpClients.ApiGW);
var fileContent = new StreamContent(file.OpenReadStream())
{
Headers =
{
ContentLength = file.Length,
ContentType = new MediaTypeHeaderValue(file.ContentType)
}
};
var formDataContent = new MultipartFormDataContent();
formDataContent.Add(fileContent, "file", file.FileName);
var response = await client.PostAsync(API.Products.ImageClassifier.PostImage(_settings.ImageClassifierApiUrl, VERSION_API), formDataContent);
if (response.IsSuccessStatusCode)
{
var result = await response.Content.ReadAsStringAsync();
var scoredProduct = JsonConvert.DeserializeObject <ClassificationResult>(result);
return(scoredProduct);
}
else
{
return(ClassificationResult.InvalidResult(response.StatusCode));
}
}
private void btnSavePicture_Click(object sender, EventArgs e)
{
ClassificationResult result = lstResults.SelectedItems[0].Tag as ClassificationResult;
if (result == null)
{
return;
}
SaveFileDialog savefile = new SaveFileDialog();
// set a default file name
savefile.FileName = result.Classifier.Name + "-" + DateTime.Now.ToFileTimeUtc() + ".png";
// set filters - this can be done in properties as well
savefile.Filter = "Image files (*.png)|*.png|All files (*.*)|*.*";
if (savefile.ShowDialog() != DialogResult.OK)
{
return;
}
Bitmap bitmap = resultsDrawingService.DrawResult(result, 1000);
bitmap.Save(savefile.FileName, ImageFormat.Png);
}
/// <summary>
/// Called when entity field need to be setted by predicted value.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="columnValueName">Name of the column value.</param>
/// <param name="result">The predicted value.</param>
/// <returns><c>true</c> - if value may be setted to field, else - <c>false</c>.</returns>
public override bool OnSetupPredictedValue(Entity entity, string columnValueName,
ClassificationResult result)
{
if (!base.OnSetupPredictedValue(entity, columnValueName, result))
{
return(false);
}
if (columnValueName != "ServiceItemId")
{
return(true);
}
if (!Guid.TryParse(result.Value, out var serviceItemId))
{
return(false);
}
Guid servicePactId = entity.GetTypedColumnValue <Guid>("ServicePactId");
var select = (Select) new Select(UserConnection)
.Column(Column.Const(1))
.From("ServiceInServicePact").As("sp")
.InnerJoin("ServiceStatus").As("ss").On("sp", "StatusId").IsEqual("ss", "Id")
.Where("sp", "ServiceItemId").IsEqual(Column.Parameter(serviceItemId, "Guid"))
.And("sp", "ServicePactId").IsEqual(Column.Parameter(servicePactId, "Guid"))
.And("ss", "Active").IsEqual(Column.Parameter(true, "Boolean"));
try {
return(select.ExecuteScalar <int>() > 0);
} catch (Exception e) {
Log.Error($"MLServicePredictedValueFilter.OnSetupPredictedValue throws exception {e}");
return(false);
}
}
private static void PlacePart(Point originOfTesselationPolygon, Part part, ClassificationResult result)
{
Part placedPart = part.Clone();
placedPart.Place(originOfTesselationPolygon);
result.Parts.Add(placedPart);
}
private bool OnSetPredictedValue(Entity entity, string columnValueName, ClassificationResult result)
{
if (columnValueName == "ServiceItemId")
{
return(OnSetPredictedServiceItem(entity, result));
}
return(true);
}
private static ClassificationResult GetDirectedResult(INestingManager nestingManager, Part part, WorkingArea workingArea, List <Part> originalParts)
{
float areaX, areaY;
if (!nestingManager.IsRectangle(workingArea, out areaX, out areaY))
{
throw new Exception("WorkingArea is not a rectangle!");
}
//Step 1: Calculate the tesselation polygon
float boxX, boxY;
nestingManager.GetRectangleBoxOfPart(part, out boxX, out boxY);
int horizontalBoxes = (int)(areaX / boxX);
int verticalBoxes = (int)(areaY / boxY);
ClassificationResult result = new ClassificationResult(ClassifierInformation);
//Step 4: Calculate the remainder polygons
List <WorkingArea> remainderPolygons = CalculateRemainderWorkingAreas(
nestingManager,
boxX,
boxY,
horizontalBoxes,
verticalBoxes,
areaX,
areaY);
//Step 5: Generate the reimainder polygons' problems
foreach (WorkingArea remainderPolygon in remainderPolygons)
{
ClassificationResult subResult = GetMainResult(nestingManager, originalParts, remainderPolygon);
if (!nestingManager.IsRectangle(remainderPolygon, out areaX, out areaY))
{
throw new Exception("WorkingArea is not a rectangle!");
}
result.ExtraPolygons.Add(nestingManager.CalculateRectangle(areaX, areaY, remainderPolygon.Placement));
result.AddSubResult(subResult, remainderPolygon.Placement);
}
for (int i = 0; i < horizontalBoxes; i++)
{
for (int j = 0; j < verticalBoxes; j++)
{
Point placementPart = new Point(i * boxX, j * boxY);
PlaceGenericPart(nestingManager, placementPart, part, result);
result.ExtraPolygons.Add(nestingManager.CalculateRectangle(boxX, boxY, placementPart));
}
}
return(result);
}
public static ClassificationResult Classify(IExpression expr, string variable)
{
var classification = new ClassificationResult();
Search(expr, e => e.DimensionKey.Key == variable, classification.SearchResult);
classification.EquationType = FindType(classification.SearchResult);
return(classification);
}
//mouse released//
private void jPanel2MouseReleased(MouseEvent evt)
{
currentX = evt.X;
currentY = evt.Y;
const double SCALE = 0.1;
BufferedImage bi = new BufferedImage(32, 32, BufferedImage.TYPE_BYTE_GRAY);
Graphics2D grph = (Graphics2D)bi.Graphics;
grph.scale(SCALE, SCALE);
grph.drawImage(canvas, 0, 0, null);
grph.dispose();
newPix = new double[32 * 32];
pixels = bi.getRGB(0, 0, 32, 32, pixels, 0, 32);
for (int i = 0; i < pixels.Length; i++)
{
newPix[i] = 255 - (pixels[i] & 0xff);
newPix[i] /= 255;
}
long start = DateTimeHelperClass.CurrentUnixTimeMillis();
network.Input = newPix;
network.calculate();
Console.WriteLine("Execution time: " + (DateTimeHelperClass.CurrentUnixTimeMillis() - start) + " milliseconds");
try
{
ImageIO.write(bi, "png", new File("number.png"));
}
catch (IOException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
double[] networkOutput = network.Output;
int maxNeuronIdx = Utils.maxIdx(networkOutput);
ClassificationResult max = new ClassificationResult(maxNeuronIdx, networkOutput[maxNeuronIdx]);
Console.WriteLine("New calculation:");
Console.WriteLine("Class: " + max.ClassIdx);
Console.WriteLine("Probability: " + max.NeuronOutput);
label.Text = Convert.ToString(max.ClassIdx);
}
private static ClassificationResult ClassifyGeneric(
INestingManager manager,
List <Part> parts,
WorkingArea workingArea)
{
float areaX, areaY;
if (!manager.IsRectangle(workingArea, out areaX, out areaY))
{
throw new Exception("WorkingArea is not a rectangle!");
}
float boxX, boxY;
manager.GetRectangleBoxOfParts(parts, out boxX, out boxY);
if (boxX > areaX || boxY > areaY)
{
throw new Exception("Part does not fit inside Working area!");
}
//Calculate how many boxes could be fit in the area
int horizontalBoxes = (int)(areaX / boxX);
int verticalBoxes = (int)(areaY / boxY);
//We build the final result using the partial results and the calculated positions of the boxes
ClassificationResult result = new ClassificationResult(ClassifierInformation)
{
WorkingArea = workingArea.Clone()
};
int partIndex = 0;
//Place parts until we run out of space
for (int i = 0; i < horizontalBoxes; i++)
{
for (int j = 0; j < verticalBoxes; j++)
{
Point subResultOrigin = new Point(i * boxX, j * boxY);
result.ExtraPolygons.Add(manager.CalculateRectangle(boxX, boxY, subResultOrigin));
Part placedPart = parts[partIndex % parts.Count].Clone();
placedPart.Place(subResultOrigin);
result.Parts.Add(placedPart);
partIndex++;
}
}
return(result);
}
private static void PrintWrongResults(
ClassificationResult classificationResult, LearningResult learningResult)
{
var nodeAndVectors = new[] {
classificationResult.WronglyAcceptedNodes
.Zip(classificationResult.WronglyAcceptedVectors, Tuple.Create),
classificationResult.WronglyRejectedNodes
.Zip(classificationResult.WronglyRejectedVectors, Tuple.Create)
};
var titles = new[] {
"WronglyAcceptedNodes", "WronglyRejectedNodes"
};
for (int i = 0; i < nodeAndVectors.Length; i++)
{
Console.WriteLine("--------------- " + titles[i] + " ---------------");
foreach (var nodeAndVector in nodeAndVectors[i])
{
var node = nodeAndVector.Item1;
var vector = nodeAndVector.Item2;
Console.WriteLine(node.Code);
Console.WriteLine(GetGoodAncestorNode(node).Code);
var groupPath = learningResult.FeatureEncoder.GetGroupPathFromNode(node);
var groupIndex = learningResult.Classifier.GetGroupIndex(groupPath);
Console.WriteLine("Group: " + (groupIndex + 1) + " (" + groupPath + ")");
Console.WriteLine("IsAccepted: "
+ learningResult.Classifier.IsAccepted(vector, groupIndex));
Console.WriteLine("IsRejected: "
+ learningResult.Classifier.IsRejected(vector, groupIndex));
var featureStrings =
learningResult.FeatureEncoder.GetFeatureStringsByVector(vector);
foreach (var featureString in featureStrings)
{
Console.WriteLine(Beautify(featureString));
}
if (i == 1)
{
Console.WriteLine("------------- Rejcting Features -------------");
var negativeVector = vector
& learningResult.Classifier.Units[groupIndex].Rejecting;
featureStrings =
learningResult.FeatureEncoder.GetFeatureStringsByVector(
negativeVector);
foreach (var featureString in featureStrings)
{
Console.WriteLine(Beautify(featureString));
}
}
Console.WriteLine("---------------------------------------------");
}
}
}
public void PredictText(ExampleSet t_Set, Example text, ref ClassificationResult result)
{
double f;
f = Calculate_F(t_Set, text.X);
if (f >= 0)
{
result.ResultCategoryId = +1;
}
else
{
result.ResultCategoryId = -1;
}
}
public async Task <IActionResult> ClassifyImage()
{
var files = Request.Form.Files;
string output = await _classificationService
.ClassifyImageCharacters(files[0]);
bool isDrug = await
_drugRegistryService
.IsDrug(output);
ClassificationResult result =
new ClassificationResult(output, isDrug);
return(Ok(result));
}
public void ClassifyKNearestNeighbour(uint k)
{
Dictionary <string, int> classCounter = _trainingSet.ClassNames.ToDictionary(className => className, className => 0);
foreach (var testObject in _testSet.Objects)
{
IList <float> values = new List <float>();
var result = new ClassificationResult {
Object = testObject
};
foreach (string className in _trainingSet.ClassNames)
{
classCounter[className] = 0;
}
foreach (var trainingObject in _trainingSet.Objects)
{
float tempValue = 0f;
for (int i = 0; i < testObject.FeaturesNumber; i++)
{
tempValue += (float)Math.Pow(testObject.Features[i] - trainingObject.Features[i], 2);
}
tempValue = (float)Math.Sqrt(tempValue);
values.Add(tempValue);
}
IList <int> minValuesIndexes = new List <int>();
for (int i = 0; i < k; i++)
{
var lowestValue = values.Where(v => !minValuesIndexes.Contains(values.IndexOf(v))).Min();
minValuesIndexes.Add(values.IndexOf(lowestValue));
}
foreach (int index in minValuesIndexes)
{
classCounter[_trainingSet.Objects[index].ClassName]++;
}
result.AssignedClassName = classCounter.First(c => c.Value == classCounter.Values.Max()).Key;
KNearestNeighbourResult.ClassificationResults.Add(result);
}
}
public IEnumerable<ClassificationResult> ClasifyOpearations(IEnumerable<BankOperation> operations)
{
List<ClassificationResult> classificationResult = new List<ClassificationResult>();
foreach (var currentOperation in operations)
{
var foundMatches = _definitionsToApply
.Where(r1 => r1.DoMatch(currentOperation))
.Select(r2 => new RuleMatch()
{
MatchedDefinition = r2.Definition,
Description = r2.GetCustomDescription()
});
var subResult = new ClassificationResult() { BankOperation = currentOperation, Matches = foundMatches };
classificationResult.Add(subResult);
}
return classificationResult;
}
public List <ClassificationResult> ClassifyAll()
{
ClassificationResult mainResult = GetMainResult(
manager,
classificationParameters.Parts,
classificationParameters.WorkingArea);
if (mainResult == null)
{
return(new List <ClassificationResult>());
}
return(new List <ClassificationResult>()
{
mainResult
});
}
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
if (obj == this)
{
return(true);
}
if (!(obj is ClassificationResult))
{
return(false);
}
ClassificationResult that = (ClassificationResult)obj;
return(this.ClassIdx == that.ClassIdx);
}
public static ClassificationResult CalculateThreshold(List <SimilarityResult> similarityResults)
{
var result = new ClassificationResult()
{
Lines = new List <ClassificationResultLine>()
};
similarityResults = similarityResults.OrderBy(s => s.AvgDistFromReferences).ToList();
for (int i = 0; i < similarityResults.Count - 1; i++)
{
var threshold = (similarityResults[i].AvgDistFromReferences + similarityResults[i + 1].AvgDistFromReferences) / 2;
CalculateRates(similarityResults, threshold, out var far, out var frr);
result.Lines.Add(new ClassificationResultLine {
Threshold = threshold, Far = far, Frr = frr, Aer = (far + frr) / 2
});
}
result.Threshold = result.Lines.OrderBy(er => er.Aer).First().Threshold;
return(result);
}
private IClassificationResult RecognizeBlurryLineGesture(TrackedGesture inputData)
{
if (!CheckTokenCriterion(inputData.FrameList, 1))
{
return(null);
}
Vertex startPoint, endPoint;
int startPointIndex = FindFirstFrameIndexWithCorrectCount(inputData.FrameList, 1, true);
int endPointIndex = FindFirstFrameIndexWithCorrectCount(inputData.FrameList, 1, false);
Touch t = inputData.FrameList[startPointIndex][0];
startPoint = new Vertex(t.x, t.y);
int maxDistantBlobFrameIndex;
//search endpoint es point with max distance from start point
//accounts for misleading data and offers robust identification of lines with disadvantage of
//more wrong positive classifications
int maxDistantBlobIndex = GetBlobMaxDistantFromPointIndex(inputData.FrameList, startPoint, out maxDistantBlobFrameIndex);
if (startPointIndex == -1 || endPointIndex == -1 ||
startPointIndex == endPointIndex || maxDistantBlobFrameIndex == -1)
{
return(null);
}
t = inputData.FrameList[endPointIndex][0];
endPoint = new Vertex(t.x, t.y);
IClassificationResult result = null;
if (CheckMaxDistanceFromLineKriterion(inputData.FrameList, startPoint, endPoint, MAXDISTFROMLINE) &&
MetricDistances.EuclideanDistance(startPoint, endPoint) > MINLINELENGTH)
{
//return RecognizeDirectionalLine(startPoint, endPoint);
result = new ClassificationResult("line", 100.0, new Sample[] { new Sample(DateTime.Now, startPoint), new Sample(DateTime.Now, endPoint) },
new KeyValuePair <String, double>("angle", GetAngle(startPoint, endPoint)));
}
return(result);
}
/// <summary>
/// Sets the predicted results to entity.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="columnValueName">Name of the column value.</param>
/// <param name="classificationResults">The classification results.</param>
/// <param name="onSetEntityValue">Function, that will be invoked before setting predicted value to entity.
/// If it returns <c>false</c>, the value won't be set.</param>
/// <returns><c>true</c> if the value was set, otherwise - <c>false</c>.</returns>
protected virtual bool SetPredictedResultsToEntity(Entity entity, string columnValueName,
List <ClassificationResult> classificationResults,
Func <Entity, string, ClassificationResult, bool> onSetEntityValue)
{
var columnValue = entity.FindEntityColumnValue(columnValueName);
ClassificationResult highlySignificantResult =
classificationResults.FirstOrDefault(result => result.Significance == HighSignificance);
if (highlySignificantResult == null)
{
return(false);
}
if (onSetEntityValue != null && !onSetEntityValue(entity, columnValueName, highlySignificantResult))
{
return(false);
}
entity.SetColumnValue(columnValue.Column, highlySignificantResult.Value);
return(true);
}
public List <ClassificationResult> ClassifyAll()
{
ClassifierInformation information = classifier.GetClassifierInformation();
try
{
startTime = DateTime.UtcNow;
List <ClassificationResult> temp = classifier.ClassifyAll();
List <ClassificationResult> result = new List <ClassificationResult>();
endTime = DateTime.UtcNow;
foreach (ClassificationResult res in temp)
{
res.TimeTaken = endTime - startTime;
float partsArea = res.Parts.Select(x => x.GetTotalArea()).Sum();
res.RemainingArea = res.WorkingArea.GetTotalArea() - partsArea;
result.Add(res);
}
return(result.OrderBy(x => x.RemainingArea).ToList());
}
catch (Exception ex)
{
ClassificationResult result = new ClassificationResult(information);
result.Error = ex;
result.HasError = true;
endTime = DateTime.UtcNow;
result.TimeTaken = endTime - startTime;
return(new List <ClassificationResult>()
{
result
});
}
}
//Result selected
private void lstResults_ItemSelectionChanged(object sender, ListViewItemSelectionChangedEventArgs e)
{
ListView item = sender as ListView;
if (item == null || item.SelectedItems.Count == 0)
{
return;
}
ClassificationResult result = item.SelectedItems[0].Tag as ClassificationResult;
if (result == null)
{
return;
}
Bitmap bitmap = resultsDrawingService.DrawResult(result, Math.Max(imgDrawArea.Size.Height, imgDrawArea.Size.Width));
imgDrawArea.Image = bitmap;
}
public async Task <IActionResult> PostImage(IFormFile file)
{
ClassificationResult result = null;
if (_settings.UseMlNetClassifier)
{
_logger.LogInformation($"Beginning a ML.NET based classification");
result = await DoMlNetClassifierAction(file);
}
else
{
_logger.LogInformation($"Beginning a Cognitive-service containerized Classification");
result = await DoCognitiveClassifierAction(file);
}
if (!result.IsOk)
{
_logger.LogInformation($"Classification failed due to HTTP CODE {result.Code}");
return(StatusCode((int)result.Code, "Request to inner container returned HTTP " + result.Code));
}
_logger.LogInformation($"Classification ended up with tag {result.Label} with a prob (0-1) of {result.Probability}");
var client = _httpClientFactory.CreateClient(HttpClients.ApiGW);
// Need to query products API for tag
var ptagsResponse = await client.GetAsync(API.Products.GetByTag(_settings.ProductsApiUrl, VERSION_API, result.Label));
if (ptagsResponse.StatusCode == HttpStatusCode.NotFound)
{
_logger.LogInformation($"Tag {result.Label} do not have any object associated");
return(Ok(Enumerable.Empty <ClassifiedProductItem>()));
}
ptagsResponse.EnsureSuccessStatusCode();
var suggestedProductsJson = await ptagsResponse.Content.ReadAsStringAsync();
var suggestedProducts = JsonConvert.DeserializeObject <IEnumerable <ClassifiedProductItem> >(suggestedProductsJson);
return(Ok(suggestedProducts));
}
public ClassificationResult ClassifyOne()
{
//This classifier does not classify
ClassificationResult result = new ClassificationResult(ClassifierInformation);
result.WorkingArea = (WorkingArea)parameters.WorkingArea.Clone();
List <Part> parts = new List <Part>();
foreach (Part part in parameters.Parts)
{
Part classifiedPart = (Part)part.Clone();
classifiedPart.Place(new Point(5, 5));
parts.Add(classifiedPart);
}
result.Parts = parts;
return(result);
}
public void CrossValidate(TextClassificationProblem problem, out double correctRatio, out double falsePositive, out double falseNegative)
{
ExampleSet v_Set; // validation set
//Logging.Info("Retrieving validation set");
v_Set = problem.ValidationSet;
int numExample = v_Set.Examples.Count;
int numCorrect = 0;
int numFP = 0, numFN = 0;
//Logging.Info("Cross Validating on validation set");
foreach (TextExample example in v_Set.Examples)
{
ClassificationResult result = new ClassificationResult();
this.Predict(problem, example, ref result);
string res = this.MinCostClassName(result);
if (res == example.Label.Name)
{
numCorrect++;
}
else if (res == className[0] && example.Label.Name == className[1])
{
numFP++;
}
else if (res == className[1] && example.Label.Name == className[0])
{
numFN++;
}
}
correctRatio = 1.0 * numCorrect / numExample;
falsePositive = 1.0 * numFP / numExample;
falseNegative = 1.0 * numFN / numExample;
Logger.Info("Correct ratio: {0}", correctRatio);
Logger.Info("False Positive: {0}", falsePositive);
Logger.Info("False Negative: {0}", falseNegative);
}
private static void PrintWrongResults(
ClassificationResult classificationResult, LearningResult learningResult) {
var nodeAndVectors = new[] {
classificationResult.WronglyAcceptedNodes
.Zip(classificationResult.WronglyAcceptedVectors, Tuple.Create),
classificationResult.WronglyRejectedNodes
.Zip(classificationResult.WronglyRejectedVectors, Tuple.Create)
};
var titles = new[] {
"WronglyAcceptedNodes", "WronglyRejectedNodes"
};
for (int i = 0; i < nodeAndVectors.Length; i++) {
Console.WriteLine("--------------- " + titles[i] + " ---------------");
foreach (var nodeAndVector in nodeAndVectors[i]) {
var node = nodeAndVector.Item1;
var vector = nodeAndVector.Item2;
Console.WriteLine(node.Code);
Console.WriteLine(GetGoodAncestorNode(node).Code);
var groupPath = learningResult.FeatureEncoder.GetGroupPathFromNode(node);
var groupIndex = learningResult.Classifier.GetGroupIndex(groupPath);
Console.WriteLine("Group: " + (groupIndex + 1) + " (" + groupPath + ")");
Console.WriteLine("IsAccepted: "
+ learningResult.Classifier.IsAccepted(vector, groupIndex));
Console.WriteLine("IsRejected: "
+ learningResult.Classifier.IsRejected(vector, groupIndex));
var featureStrings =
learningResult.FeatureEncoder.GetFeatureStringsByVector(vector);
foreach (var featureString in featureStrings) {
Console.WriteLine(Beautify(featureString));
}
if (i == 1) {
Console.WriteLine("------------- Rejcting Features -------------");
var negativeVector = vector
& learningResult.Classifier.Units[groupIndex].Rejecting;
featureStrings =
learningResult.FeatureEncoder.GetFeatureStringsByVector(
negativeVector);
foreach (var featureString in featureStrings) {
Console.WriteLine(Beautify(featureString));
}
}
Console.WriteLine("---------------------------------------------");
}
}
}
