public void CompareReviews() { const string evidenceRepo = @"C:\Dragon\Evidence\"; var positiveReviews = new Evidence("Positive", evidenceRepo, loadEvidence: true); var negativeReviews = new Evidence("Negative", evidenceRepo, loadEvidence: true); var classifier = new Classifier(positiveReviews, negativeReviews); var reviewUrls = new List<string>(); using (var file = new StreamReader(@"C:\Dragon\RawData\ReviewUrls.txt")) { string line; while ((line = file.ReadLine()) != null) { if (string.IsNullOrWhiteSpace(line.Trim())) continue; reviewUrls.Add(line.Trim()); } } var boilerPipeContents = Helper.GetUrlContentsViaBoilerPipe(reviewUrls); var readabilityContents = Helper.GetUrlContentsViaReadability(reviewUrls); var uClassifyResults = Helper.GetUClassifyReviewScores(reviewUrls); var dragonResultsViaReadability = new Dictionary<string, double>(); var dragonResultsViaBoilerPipe = new Dictionary<string, double>(); foreach (var content in boilerPipeContents) { var scores = classifier.Classify(content.Value, DragonHelper.DragonHelper.TokenCharMappings, DragonHelper.DragonHelper.ExcludeList); var positive = scores["Positive"]; dragonResultsViaBoilerPipe.Add(content.Key, positive); } foreach (var content in readabilityContents) { var scores = classifier.Classify(content.Value, DragonHelper.DragonHelper.TokenCharMappings, DragonHelper.DragonHelper.ExcludeList); var positive = scores["Positive"]; dragonResultsViaReadability.Add(content.Key, positive); } Console.Out.WriteLine("Url,Dragon_Readability,Dragon_BoilerPipe,uClassify"); foreach (var url in reviewUrls) { var output = string.Format("{0}, {1}, {2}, {3}", url, dragonResultsViaReadability[url], dragonResultsViaBoilerPipe[url], uClassifyResults[url]); Console.Out.WriteLine(output); } //foreach (var dragonResult in dragonResultsViaReadability) //{ // var output = string.Format("{0}, {1}, {2}", dragonResult.Key, dragonResult.Value, uClassifyResults[dragonResult.Key]); // Console.Out.WriteLine(output); //} }
private static string[] GetDetails(Classifier classifier, List <FeatureVector> vectors, TextIdMapper classToClassId, TextIdMapper featureToFeatureId) { var detailsAsText = new string[vectors.Count]; for (int v_i = 0; v_i < vectors.Count; v_i++) { double[] details; //int sysClass = classifier.Classify(vectors[v_i], out details); Debug.Assert(details.Length == 1); detailsAsText[v_i] = string.Format($"{details[0]:0.00000}"); } return(detailsAsText); }
//[TestMethod] public void ExtractContentsAndClassify() { const string evidenceRepo = @"C:\Dragon\Evidence\"; var positiveReviews = new Evidence("Positive", evidenceRepo, loadEvidence: true); var negativeReviews = new Evidence("Negative", evidenceRepo, loadEvidence: true); var classifier = new Classifier(positiveReviews, negativeReviews); const string reviewUrl = "http://www.theverge.com/2012/9/30/3433110/amazon-kindle-paperwhite-review"; var extractedContent = Helper.GetUrlContentsViaReadability(reviewUrl); var scores = classifier.Classify(extractedContent, DragonHelper.DragonHelper.TokenCharMappings, DragonHelper.DragonHelper.ExcludeList); var positiveFromUrl = scores["Positive"]; Assert.IsNotNull(positiveFromUrl); string testData; using (var sr = new StreamReader(@"C:\Users\Amrish\Desktop\Review.txt", Encoding.UTF7)) { testData = sr.ReadToEnd(); } scores = classifier.Classify(testData, DragonHelper.DragonHelper.TokenCharMappings, DragonHelper.DragonHelper.ExcludeList); var positiveFromContents = scores["Positive"]; Assert.IsNotNull(positiveFromContents); }
public void ClassifierSupportsWhitespace() { var text = " "; var tree = SyntaxTree.Parse(text); var fullSpan = tree.Root.FullSpan; Assert.Collection( Classifier.Classify(tree, fullSpan), span => { Assert.Equal(Classification.Text, span.Classification); Assert.Equal(TextSpan.FromBounds(0, 7), span.Span); Assert.Equal(" ", tree.File.ToString(span.Span)); } ); }
public void ClassificationTest_Classify_Quantity() { const Classifier.ColumnType testColumn = Classifier.ColumnType.Quantity; Classifier clf = Classifier.GetInstance(); Assert.IsNotNull(clf); LoadFrequencyValues(clf); var result = clf.Classify(new List <string>() { "1", "2", "3", "4", "5", "6" }); Assert.AreEqual(testColumn, result.Min().columnType); Assert.IsTrue(result.Count > 1); }
public void ClassificationTest_Classify_MPN() { const Classifier.ColumnType testColumn = Classifier.ColumnType.PartNumber; Classifier clf = Classifier.GetInstance(); Assert.IsNotNull(clf); LoadFrequencyValues(clf); var result = clf.Classify(new List <string>() { "C1608X7R1E105K080AB", "MC0805N100J201CT", "GRM2165C2A471JA01D", "VS-15MQ040NPBF", "EMVA250ADA101MF80G", "251R15S221JV4E" }); Assert.AreEqual(testColumn, result.Min().columnType); Assert.IsTrue(result.Count > 1); }
public void Train() { // Example binary data double[][] inputs = { new double[] { -1, -1 }, new double[] { -1, 1 }, new double[] { 1, -1 }, new double[] { 1, 1 } }; int[] xor = // xor labels { -1, 1, 1, -1 }; instance.Train(xor, inputs, CancellationToken.None); var result = instance.Classify(inputs); Assert.AreEqual(4, result.Length); instance.Save(fileName); Assert.IsTrue(File.Exists(fileName)); instance.Load(fileName); }
public void ClassifyHappyPath() { Logger.Debug("Hello"); const string evidenceRepo = @"C:\Dragon\Evidence\"; var positiveReviews = new Evidence("Positive", evidenceRepo, loadEvidence: true); var negativeReviews = new Evidence("Negative", evidenceRepo, loadEvidence: true); string testData; using (var sr = new StreamReader(@"C:\Users\Amrish\Desktop\Review.txt", Encoding.UTF7)) { testData = sr.ReadToEnd(); } var classifier = new Classifier(positiveReviews, negativeReviews); var scores = classifier.Classify(testData, DragonHelper.DragonHelper.TokenCharMappings, DragonHelper.DragonHelper.ExcludeList); var positive = scores["Positive"]; Assert.IsNotNull(positive); }
public JsonResult classify_extra_stuff(string address, int month) { Apartment apartment = _context.Apartment.Include(m => m.malfunctions).FirstOrDefault(x => x.Address.Contains(address)); InitiallizeTrainData(month); Classifier classifier = new Classifier(); classifier.TrainClassifier(table); var name = classifier.Classify(new double[] { apartment.RoomsNumber, month, apartment.Longitude + apartment.Latitude }); string message; message = name.ToLower() == "above" ? "Consider putting more stuff at this area and this month, there should be a lot of malfunctions" : "Your Stuff is quiet enough! :) No need to get extra."; return(Json($"{{\"message\":\"{message}\"}}")); }
private void button1_Click(object sender, EventArgs e) { if ((textBox1.Text.Length > 0) && (textBox2.Text.Length > 0) && (textBox3.Text.Length > 0) && (textBox4.Text.Length > 0)) { double t1, t2, t3, t4; using (SqlCommand cmd = new SqlCommand("truncate table temp_z", cn)) { cn.Open(); cmd.ExecuteNonQuery(); cn.Close(); } t1 = Convert.ToDouble(textBox1.Text); t2 = Convert.ToDouble(textBox2.Text); t3 = Convert.ToDouble(textBox3.Text); t4 = Convert.ToDouble(textBox4.Text); DataTable table = new DataTable(); using (SqlCommand cmd = new SqlCommand("select * from dataset", cn)) { using (SqlDataAdapter adp = new SqlDataAdapter(cmd)) { adp.Fill(table); } } Classifier classifier = new Classifier(); classifier.TrainClassifier(table); string val = classifier.Classify(new double[] { t1, t2, t3, t4 }); if (val == "Good") { label2.Text = "Good"; } else if (val == "Fair") { label2.Text = "Fair"; } else if (val == "Poor") { label2.Text = "Poor"; } } else { MessageBox.Show("ENTER values!"); } }
/// <summary> /// /// </summary> /// <returns></returns> public override IModel Convert() { var mapping = GetOrCreateMappings <MappingIfcBuildingToFacility>(); var classifier = new Classifier(this); var buildings = SourceRepository.Instances.OfType <IIfcBuilding>().ToList(); var facilities = new List <CobieFacility>(buildings.Count); foreach (var building in buildings) { var facility = TargetRepository.Instances.New <CobieFacility>(); facility = mapping.AddMapping(building, facility); if (_classify) { classifier.Classify(facility); } facilities.Add(facility); } return(TargetRepository); }
public void ClassifyHappyPath() { Logger.Debug("Hello"); const string evidenceRepo = @"C:\Dragon\Evidence\"; var positiveReviews = new Evidence("Positive", evidenceRepo, loadEvidence: true); var negativeReviews = new Evidence("Negative", evidenceRepo, loadEvidence: true); string testData; using (var sr = new StreamReader(@"C:\Users\Amrish\Desktop\Review.txt", Encoding.UTF7)) { testData = sr.ReadToEnd(); } var classifier = new Classifier(positiveReviews, negativeReviews); var scores = classifier.Classify(testData, DragonHelper.DragonHelper.TokenCharMappings, DragonHelper.DragonHelper.ExcludeList); var positive = scores["Positive"]; Assert.IsNotNull(positive); }
/// <summary> /// Performs this job. /// </summary> /// <returns>The validation results.</returns> /// <remarks></remarks> public ValidationJobResult Perform() { Validator.TrainingFunction = delegate(List <Instance> train) { Classifier.Train(train); }; Validator.ClassifyFunction = delegate(Instance test) { return(Classifier.Classify(test)); }; Stopwatch timer = new Stopwatch(); timer.Start(); Validator.Compute(); timer.Stop(); return(new ValidationJobResult(this, Validator.ConfusionMatrix, timer.Elapsed)); }
public static async Task <int> WriteResultsAsync(TextWriter writer, MarkdownLinksVerifierConfiguration config, string?rootDirectory = null) { if (writer is null) { throw new ArgumentNullException(nameof(writer)); } if (config is null) { throw new ArgumentNullException(nameof(config)); } var returnCode = 0; rootDirectory ??= Directory.GetCurrentDirectory(); await writer.WriteLineAsync($"Starting Markdown Links Verifier in '{rootDirectory}'."); foreach (string file in Directory.EnumerateFiles(rootDirectory, "*.md", SearchOption.AllDirectories)) { string?directory = Path.GetDirectoryName(file); if (directory is null) { throw new InvalidOperationException($"Cannot get directory for '{file}'."); } MarkdownDocument document = Markdown.Parse(await File.ReadAllTextAsync(file)); foreach (LinkInline link in document.Descendants <LinkInline>()) { LinkClassification classification = Classifier.Classify(link.Url); ILinkValidator validator = LinkValidatorCreator.Create(classification, directory); if (!config.IsLinkExcluded(link.Url) && !validator.IsValid(link.Url, file)) { await writer.WriteLineAsync($"::error::In file '{file}': Invalid link: '{link.Url}' relative to '{directory}'."); returnCode = 1; } } } return(returnCode); }
public static string[] GetDistributionDetails(Classifier classifier, List <FeatureVector> vectors, TextIdMapper classToClassId) { string[] details = new string[vectors.Count]; for (int v_i = 0; v_i < vectors.Count; v_i++) { double[] distribution; //int sysClass = classifier.Classify(vectors[v_i], out distribution); var distribution_sorted = SearchHelper.GetMaxNItems(distribution.Length, distribution); // Output the results: StringBuilder sb = new StringBuilder(); foreach (var classId in distribution_sorted) { // Output the results: sb.AppendFormat("\t{0}\t{1:0.00000}", classToClassId[classId], distribution[classId]); } details[v_i] = sb.ToString(); } return(details); }
public void ClassifierSupportsABlock() { var text = AnnotatedText.Parse( @" { }" ); var tree = SyntaxTree.Parse(text.Text); var fullSpan = tree.Root.FullSpan; var newLineWidth = Environment.NewLine.Length; Assert.Collection( Classifier.Classify(tree, fullSpan), span => { Assert.Equal(Classification.Text, span.Classification); Assert.Equal(TextSpan.FromBounds(0, 1), span.Span); Assert.Equal("{", tree.File.ToString(span.Span)); }, span => { Assert.Equal(Classification.Text, span.Classification); Assert.Equal(TextSpan.FromBounds(1, 1 + newLineWidth), span.Span); Assert.Equal(Environment.NewLine, tree.File.ToString(span.Span)); }, span => { // eof token Assert.Equal(Classification.Text, span.Classification); Assert.Equal(TextSpan.FromBounds(1 + newLineWidth, 2 + newLineWidth), span.Span); Assert.Equal("}", tree.File.ToString(span.Span)); } ); }
private void Classify() { if (!IsStringCorrect(ObjViewModel.CarType, ObjViewModel.Color, ObjViewModel.Origin)) { MessageBox.Show(Resources.ErrorMessage); } else { if (_classifer != null) { var results = _classifer.Classify(new List <string>() { ObjViewModel.CarType, ObjViewModel.Color, ObjViewModel.Origin }); var bestResult = results.OrderByDescending(x => x.Value).FirstOrDefault(); var strBuilder = new StringBuilder(); strBuilder.AppendLine(Resources.CategoryQuestion); strBuilder.AppendLine(string.Format(Resources.ResultForma, bestResult.Key, bestResult.Value)); Result = strBuilder.ToString(); } } }
/// <summary> /// Returns a customized string explaining the state of a single IEQ parameter. /// </summary> /// <param name="data">Value (1-100) for given IEQ factor</param> /// <param name="type">The type of IEQ factor</param> /// <returns>Customized string explaining state of IEQ paramter</returns> private string GetMessage(double data, string type) { string returnString = ""; //String returned //Use the classifier to determine the state of the given IEQ factor int classification = Classifier.Classify(data, Constants.SCORE_RANGES); //Constructs the returnString based on the classification switch (classification) { case 1: returnString = AppResources.terrible + " " + type + "!"; break; case 2: returnString = AppResources.bad + " " + type + "!"; break; case 3: returnString = AppResources.acceptable + " " + type + "!"; break; case 4: returnString = AppResources.good + " " + type + "!"; break; case 5: returnString = AppResources.perfect + " " + type + "!"; break; default: break; } return(returnString); }
static int TestTrainer(Classifier<Sample> c, IEnumerable<Sample> pointsPos, IEnumerable<Sample> pointsNeg) { //Console.WriteLine(errors / 40f + "% error rate."); //Console.WriteLine(); return pointsPos.Count(s => c.Classify(s) <= 0) + pointsNeg.Count(s => c.Classify(s) >= 0); }
//[TestMethod] public void ExtractContentsAndClassify() { const string evidenceRepo = @"C:\Dragon\Evidence\"; var positiveReviews = new Evidence("Positive", evidenceRepo, loadEvidence: true); var negativeReviews = new Evidence("Negative", evidenceRepo, loadEvidence: true); var classifier = new Classifier(positiveReviews, negativeReviews); const string reviewUrl = "http://www.theverge.com/2012/9/30/3433110/amazon-kindle-paperwhite-review"; var extractedContent = Helper.GetUrlContentsViaReadability(reviewUrl); var scores = classifier.Classify(extractedContent, DragonHelper.DragonHelper.TokenCharMappings, DragonHelper.DragonHelper.ExcludeList); var positiveFromUrl = scores["Positive"]; Assert.IsNotNull(positiveFromUrl); string testData; using (var sr = new StreamReader(@"C:\Users\Amrish\Desktop\Review.txt", Encoding.UTF7)) { testData = sr.ReadToEnd(); } scores = classifier.Classify(testData, DragonHelper.DragonHelper.TokenCharMappings, DragonHelper.DragonHelper.ExcludeList); var positiveFromContents = scores["Positive"]; Assert.IsNotNull(positiveFromContents); }
static void Main(string[] args) { //ExStart:ApplyingLicense /** * Applying product license * Please uncomment the statement if you do have license. */ // const string licensePath = "../../../../GroupDocs.Classification.NET.Full.lic"; // new License().SetLicense(licensePath); //ExEnd:ApplyingLicense Console.WriteLine("SentimentClassifier initialization is started."); sentimentClassifier = new SentimentClassifier(); Console.WriteLine("SentimentClassifier was initialized."); var sentiments = new string[] { "Now that that is out of the way, this thing is a beast. It is fast and runs cool.", "When I used compressed air a cloud of dust bellowed out from the card (small scuffs and scratches)." }; #region Classify raw text with Classify method of SentimentClassifier class. Console.WriteLine("\nClassify raw text with Classify method of SentimentClassifier class."); foreach (var sentiment in sentiments) { try { Stopwatch sw = new Stopwatch(); sw.Start(); var result = sentimentClassifier.Classify(sentiment); Console.WriteLine($"{sentiment}"); Console.WriteLine($"This sentiment is {result.BestClassName} with probability {result.BestClassProbability}. Elapsed: {sw.ElapsedMilliseconds}ms\n"); } catch (ApiException e) { Console.WriteLine(e.Message); } } #endregion #region Classify raw text with PositiveProbability method of SentimentClassifier class. Console.WriteLine("\nClassify raw text with PositiveProbability method of SentimentClassifier class."); foreach (var sentiment in sentiments) { try { Stopwatch sw = new Stopwatch(); sw.Start(); var positiveProbability = sentimentClassifier.PositiveProbability(sentiment); Console.WriteLine($"{sentiment}"); Console.WriteLine($"This sentiment is {(positiveProbability > 0.5 ? "positive" : "negative")}. Elapsed: {sw.ElapsedMilliseconds}ms\n"); } catch (ApiException e) { Console.WriteLine(e.Message); } } #endregion Console.WriteLine("Classifier initialization is started."); classifier = new Classifier(); Console.WriteLine("Classifier was initialized."); ClassificationResponse response; #region Classify raw text with Classifier class. Console.WriteLine("\nClassify raw text with Classifier class."); // Simple IAB-2 text classification response = classifier.Classify("Medicine is an important part of our lifes"); Console.WriteLine($"{response.BestClassName}, {response.BestClassProbability}"); // Change taxonomy and best classes count response = classifier.Classify("Medicine is an important part of our lifes", 2, Taxonomy.Documents, PrecisionRecallBalance.Recall); Console.WriteLine($"{response.BestClassName}, {response.BestClassProbability}"); // Classify sentiment response = classifier.Classify("This is a new must-have thing.", 2, Taxonomy.Sentiment); Console.WriteLine($"{response.BestClassName}, {response.BestClassProbability}"); #endregion #region Classify documents with IAB-2 taxonomy. Console.WriteLine("\nClassify documents with IAB-2 taxonomy."); // Classify PDF document by path with IAB-2 taxonomy and return 2 best results ClassifyByFilePath("Annotations.pdf", Taxonomy.Iab2, 2); // Classify doc document by path with IAB-2 taxonomy and return the best result ClassifyByFilePath("four-pages.docx", Taxonomy.Iab2, 1); // Classify txt document by path with IAB-2 taxonomy and return 4 best results ClassifyByFilePath("Letter.txt", Taxonomy.Iab2, 4); #endregion #region Classify documents with Documents taxonomy. Console.WriteLine("\nClassify documents with Documents taxonomy."); // Classify PDF document from stream with Documents taxonomy and return 2 best results ClassifyStream("Annotations.pdf", Taxonomy.Documents, 2); // Classify doc document from stream with Documents taxonomy and return the best result ClassifyStream("four-pages.docx", Taxonomy.Documents, 1); // Classify txt document from stream with Documents taxonomy and return 3 best results ClassifyStream("Letter.txt", Taxonomy.Documents, 3); #endregion #region Classify documents with Sentiment taxonomy. Console.WriteLine("\nClassify documents with Sentiment taxonomy."); // Classify PDF document from stream with Sentiment taxonomy and return 2 best results ClassifyStream("Annotations.pdf", Taxonomy.Sentiment, 2); // Classify doc document from stream with Sentiment taxonomy and return the best result ClassifyStream("four-pages.docx", Taxonomy.Sentiment, 1); // Classify txt document from stream with Sentiment taxonomy and return 3 best results ClassifyStream("Letter.txt", Taxonomy.Sentiment, 2); #endregion #region Classify password-protected documents. Console.WriteLine("\nClassify password-protected documents."); try { response = classifier.Classify("password-protected.docx", dataFolderPath, password: "******"); Console.WriteLine($"password-protected.docx: {response.BestClassName}, {response.BestClassProbability}"); } catch (ApiException e) { Console.WriteLine(e.Message); } try { using (var fs = File.OpenRead(Path.Combine(dataFolderPath, "password-protected.docx"))) { response = classifier.Classify(fs, password: "******"); Console.WriteLine($"password-protected.docx: {response.BestClassName}, {response.BestClassProbability}"); } } catch (ApiException e) { Console.WriteLine(e.Message); } #endregion #region Print taxonomy classes. Console.WriteLine("\nPrint taxonomy classes."); // Print IAB-2 taxonomy classes Console.WriteLine("IAB-2 taxonomy classes: "); Console.WriteLine(String.Join(" ", TaxonomyClasses.Iab2Classes)); // Print Documents taxonomy classes Console.WriteLine("Documents taxonomy classes: "); Console.WriteLine(String.Join(" ", TaxonomyClasses.DocumentsClasses)); // Print Sentiment taxonomy classes Console.WriteLine("Sentiment taxonomy classes: "); Console.WriteLine(String.Join(" ", TaxonomyClasses.SentimentClasses)); #endregion Console.WriteLine("Done..."); Console.ReadKey(); }
public void ClassifyLocalLink_FileWithDirectory_MixedSlashes() { Assert.Equal(LinkClassification.Local, Classifier.Classify(@"path/to\myfile.txt")); }
public void ClassifyLocalLink_FileWithDirectory_Backslash() { Assert.Equal(LinkClassification.Local, Classifier.Classify(@"path\to\myfile.txt")); }
protected override async void OnActivityResult(int requestCode, [GeneratedEnum] Result resultCode, Intent data) { base.OnActivityResult(requestCode, resultCode, data); switch (requestCode) { case 100: if (resultCode == Result.Ok && data != null) { Intent mIntent = new Intent(this, typeof(ConfirmedCookingActivityViaSpeech)); IList <string> mResult = data.GetStringArrayListExtra(RecognizerIntent.ExtraResults); System.Diagnostics.Debug.WriteLine(mResult[0]); string command = mResult[0]; Classifier mClassifier = new Classifier(command); ClassifiedResult mResp = mClassifier.Classify(); switch (mResp.Type) { case VoiceCommandType.BOOK_ME_CHEAPEST_CAB_FROM_X_TO_Y: string recs = mResp.GetData("source"); if (!recs.Equals("")) { mSourceAddress = recs; } mDestinationAddress = mResp.GetData("destination"); error = "Booking Cheapest cab from " + mSourceAddress + "to" + mDestinationAddress; speakUp(); mIntent.PutExtra("mSource", mSourceAddress); mIntent.PutExtra("mDestination", mDestinationAddress); StartActivity(mIntent); break; case VoiceCommandType.BOOK_TO_CUSTOM_LOCATION: mDestinationAddress = mResp.GetData("location"); mIntent.PutExtra("mSource", mSourceAddress); mIntent.PutExtra("mDestinationAddress", mDestinationAddress); StartActivity(mIntent); break; case VoiceCommandType.BOOK_ME_A_CAB_FROM_X_TO_Y: { CabsAPI api = new CabsAPI(); string source = mResp.GetData("source"); string destination = mResp.GetData("destination"); mLoadingDialog.Show(); PlacesResponse mResposneSource = await api.GetPlaceLocation(source, token); PlacesResponse mResponseDest = await api.GetPlaceLocation(destination, token); if (mResposneSource.Code == ResponseCode.SUCCESS && mResponseDest.Code == ResponseCode.SUCCESS) { string msource = mResposneSource.Location.Latitude + "," + mResposneSource.Location.Longitude; string mDest = mResponseDest.Location.Latitude + "," + mResponseDest.Location.Longitude; ReverseGeoResposne mResSrc = await api.GetReverseCodingResultlatlng(token, msource); ReverseGeoResposne mResDest = await api.GetReverseCodingResultlatlng(token, mDest); if (mResSrc.Code == ResponseCode.SUCCESS && mResDest.Code == ResponseCode.SUCCESS) { error = "Booking cab from " + source + "to" + destination; speakUp(); mLoadingDialog.Dismiss(); mSourceAddress = mResSrc.FormattedAddress; mDestinationAddress = mResDest.FormattedAddress; mIntent.PutExtra("mSource", mSourceAddress); mIntent.PutExtra("mDestination", mDestinationAddress); StartActivity(mIntent); } else { error = "Google maps error"; speakUp(); return; } } else { error = "These places are not there in your notebook"; speakUp(); return; } break; } case VoiceCommandType.INVALID_COMMAND: error = "Invalid Commmand Please try again"; speakUp(); break; } } break; } }
public void ClassifyLocalLink_FromRoot() { Assert.Equal(LinkClassification.Local, Classifier.Classify(@"~/path/to/file.md")); }
/// <summary> /// Classifies an instance based on a set of feature values /// </summary> /// <param name="instance">Feature values, indexed by their name</param> /// <returns>Ranked results of the classification, class name to "probability"</returns> public Dictionary <ShapeType, double> Classify(Dictionary <string, object> instance) { return(Classifier.Classify(instance)); }
public void ClassifyEmptyLink_ConsideredAsLocal() { Assert.Equal(LinkClassification.Local, Classifier.Classify("")); }
public int Analyze(string message) { var scores = classifier.Classify(message, Dictionary.Helpers.VocabularyHelper.ExcludeList); return(scores["Positive"] > scores["Negative"] ? 1 : -1); }
public static async Task <HttpResponseMessage> AboutQueryRun( [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequestMessage req, ILogger log, [EventStream(Constants.Domain_Query, "Test Case", "123")] EventStream esTest, [Projection(Constants.Domain_Query, "Test Case", "123", nameof(Query_Summary_Projection))] Projection prjTest, [Classifier(Constants.Domain_Query, "Test Case", "123", nameof(Query_InError_Classifier))] Classifier clsTest) { log.LogInformation("C# HTTP trigger function processed a request."); if (null != esTest) { log.LogInformation($"Event stream created {esTest}"); // add a test event await esTest.AppendEvent(new QueryCreated("Test Query", Guid.NewGuid(), aurhorisationTokenIn : "Duncan test 123" )); } else { log.LogWarning($"Unable to create event stream parameter"); } if (null != prjTest) { log.LogInformation($"Projection created {prjTest}"); // Query_Summary_Projection projection = await prjTest.Process <Query_Summary_Projection>(); if (null != projection) { log.LogInformation($"Projection created {projection.CurrentSequenceNumber} status {projection.CurrentState } "); } } else { log.LogWarning($"Unable to create projection parameter"); } if (null != clsTest) { log.LogInformation($"Classifier created {clsTest}"); var result = await clsTest.Classify <Query_InError_Classifier>(forceExclude : true); log.LogInformation($"Classifier created {clsTest.ClassifierTypeName} result {result } "); } else { log.LogWarning($"Unable to create classifier parameter"); } // parse query parameter string name = req.GetQueryNameValuePairsExt()[@"name"]; // Get request body dynamic data = await req.Content.ReadAsAsync <object>(); // Set name to query string or body data name = name ?? data?.name; return(name == null ? req.CreateResponse(HttpStatusCode.OK, "The Long Run - Leagues Domain - Function App") : req.CreateResponse(HttpStatusCode.OK, GetFunctionAbout(name))); }
public void ClassifyLocalLink_FromParentDirectory() { Assert.Equal(LinkClassification.Local, Classifier.Classify(@"../path/to/file.md")); }
protected override object?RenderLine(IReadOnlyList <string> lines, int lineIndex, object?state) { var syntaxTree = default(SyntaxTree); if (state == null) { var text = string.Join(Environment.NewLine, lines); var sourceText = SourceText.From(text); syntaxTree = SyntaxTree.Parse(sourceText); } else { syntaxTree = (SyntaxTree)state; } var lineSpan = syntaxTree.Text.Lines[lineIndex].Span; var classifiedSpans = Classifier.Classify(syntaxTree, lineSpan); foreach (var classifiedSpan in classifiedSpans) { var tokenText = syntaxTree.Text.ToString(classifiedSpan.Span); switch (classifiedSpan.Classification) { case Classification.Text: Console.ForegroundColor = ConsoleColor.DarkGray; break; case Classification.Keyword: Console.ForegroundColor = ConsoleColor.Magenta; break; case Classification.Identifier: Console.ForegroundColor = ConsoleColor.Cyan; break; case Classification.Number: Console.ForegroundColor = ConsoleColor.DarkCyan; break; case Classification.String: Console.ForegroundColor = ConsoleColor.DarkYellow; break; case Classification.Punctuation: Console.ForegroundColor = ConsoleColor.White; break; case Classification.Comment: Console.ForegroundColor = ConsoleColor.DarkGreen; break; default: throw new Exception(); } Console.Write(tokenText); Console.ResetColor(); } return(syntaxTree); }
public void start_testing(string path) { Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); DataTable table = new DataTable(); using (SqlCommand cmd = new SqlCommand("select * from dataset", cn)) { using (SqlDataAdapter adp = new SqlDataAdapter(cmd)) { adp.Fill(table); } } Classifier classifier = new Classifier(); classifier.TrainClassifier(table); string pathconn = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source='" + path + "';Extended Properties=\"Excel 12.0 Xml;HDR=NO;IMEX=1;\""; OleDbConnection conn = new OleDbConnection(pathconn); OleDbDataAdapter dataadp = new OleDbDataAdapter("select * from [Sheet1$]", conn); DataTable ds = new DataTable(); dataadp.Fill(ds); // ds.Rows[0].Delete(); int t1 = 0, t2 = 0, t3 = 0, t4 = 0; for (int i = 1; i < ds.Rows.Count; i++) { try { using (SqlCommand cmd = new SqlCommand("truncate table temp_z", cn)) { cn.Open(); cmd.ExecuteNonQuery(); cn.Close(); } t1 = Convert.ToInt32(ds.Rows[i]["f2"]); t2 = Convert.ToInt32(ds.Rows[i]["f3"]); t3 = Convert.ToInt32(ds.Rows[i]["f4"]); t4 = Convert.ToInt32(ds.Rows[i]["f5"]); string val = classifier.Classify(new double[] { t1, t2, t3, t4 }); if (val == "Introvert") { label2.Text = "Introvert"; } else if (val == "Ambivert") { label2.Text = "Ambivert"; } else if (val == "Extrovert") { label2.Text = "Extrovert"; } using (SqlCommand cmdd = new SqlCommand("insert into output_master_naive(test1, test2, test3,test4,result) values(@test1, @test2, @test3,@test4,@result)", cn)) { cmdd.Parameters.AddWithValue("test1", t1); cmdd.Parameters.AddWithValue("test2", t2); cmdd.Parameters.AddWithValue("test3", t3); cmdd.Parameters.AddWithValue("test4", t4); cmdd.Parameters.AddWithValue("result", val); cn.Open(); cmdd.ExecuteNonQuery(); cn.Close(); } } catch (Exception ex) { MessageBox.Show("ERROR"); } } MessageBox.Show("DONE EXECUTING"); stopwatch.Stop(); TimeSpan ts = stopwatch.Elapsed; string TotalTime = ts.Seconds.ToString(); SetTime.Time = Convert.ToDouble(TotalTime); // SetTime.FilePath = OutPutPath; lblShow.Text = TotalTime; button2.Visible = true; }
static void Main(string[] args) { Console.WriteLine("Classifier initialization is started."); classifier = new Classifier(); Console.WriteLine("Classifier was initialized."); // Parse input and output folders. Parser.Default.ParseArguments <Options>(args) .WithParsed <Options>(o => { //ExStart:ApplyingLicense /** * Applying product license * Please uncomment the statement if you do have license. */ // const string licensePath = "../../../../GroupDocs.Classification.NET.Full.lic"; // new License().SetLicense(licensePath); //ExEnd:ApplyingLicense if (!Directory.Exists(o.Input)) { throw new Exception("Input directory doesn't exist."); } // Creates <output> directory if it doesn't exist. if (!Directory.Exists(o.Output)) { Directory.CreateDirectory(o.Output); } // For each file in <input> folder. foreach (var path in Directory.GetFiles(o.Input)) { var filename = Path.GetFileName(path); var directory = Path.GetDirectoryName(path); try { Stopwatch sw = new Stopwatch(); sw.Start(); // Classifies file with Documents taxonomy. var result = classifier.Classify(filename, directory, taxonomy: Taxonomy.Documents); Console.WriteLine(filename + ": " + result.BestClassName); Console.WriteLine($"Elapsed: {sw.ElapsedMilliseconds}ms"); // Creates class directory in the <output> folder(if it doesn't exist) var organizedDirectory = Path.Combine(o.Output, result.BestClassName); if (!Directory.Exists(organizedDirectory)) { Directory.CreateDirectory(organizedDirectory); } // Copies the document. File.Copy(path, Path.Combine(organizedDirectory, filename)); } catch (Exception e) { Console.WriteLine(e.Message); } } }); }
static void Main(string[] args) { string pathToData = "DATA"; string pathToResults = "wynik.txt"; bool runOneTime = true; DirectoryInfo di = new DirectoryInfo(pathToData + "\\letterB"); using (var tw = new StreamWriter(pathToResults, true)) { foreach (var csv in di.GetFiles("*.csv")) { IDataProvider dataProvider = new MockDataProvider(); Classifier <string> classifier = new Classifier <string>(); var sampleData = dataProvider.GetTrainingData(pathToData, csv.Name, ExcludeType.b) as List <InformationModel>; classifier.Teach(sampleData); List <List <string> > values = new List <List <string> >(); values.AddRange(File.ReadAllLines(csv.FullName) .Skip(1) .Select(FromCsv) .ToList()); Dictionary <string, int> counter = new Dictionary <string, int>() { { "m", 0 }, { "f", 0 }, { "b", 0 } }; foreach (var list in values) { IDictionary <string, double> tempDict = classifier.Classify(list); double min = 0; string cat = ""; foreach (var item in tempDict) { if (min == 0 || min > item.Value) { min = item.Value; cat = item.Key; } } counter[cat]++; } foreach (var item in counter) { tw.Write("{1}; ", item.Key, item.Value); } tw.WriteLine(); if (runOneTime) { break; } } } }