public async Task <IActionResult> CreateClassifier(Classifiers classifiers) { db.Classifiers.Add(classifiers); await db.SaveChangesAsync(); return(RedirectToAction("Index")); }
public IEnumerable <DownloadEntry> GetDownloadsEntries(string classifier = null) { List <DownloadEntry> entries = new List <DownloadEntry>(); if (Artifact != null) { entries.Add(Artifact); } if (classifier == null || Classifiers == null) { return(entries); } if (Classifiers.ContainsKey(classifier)) { Classifiers[classifier].IsNatives = true; entries.Add(Classifiers[classifier]); } else { throw new KeyNotFoundException($"A specified classifier is not presented in list: '{classifier}'."); } return(entries); }
private void OnGetClassifiers(Classifiers classifiers) { if (classifiers != null) { bool bFound = false; foreach (var classifier in classifiers.classifiers) { if (!string.IsNullOrEmpty(m_ClassifierName) && !classifier.name.ToLower().StartsWith(m_ClassifierName.ToLower())) { continue; } if (classifier.language != m_Language) { continue; } m_NaturalLanguageClassifier.GetClassifier(classifier.classifier_id, OnGetClassifier); bFound = true; } if (!bFound) { Log.Error("NaturalLanguageClassifierWidget", "No classifiers found that match {0}", m_ClassifierName); } } }
private void OnCheckService(Classifiers classifiers) { if (m_Callback != null) { m_Callback(SERVICE_ID, classifiers != null); } }
private Classifiers ListClassifiers(bool?verbose = null) { Console.WriteLine("\nAttempting to ListClassifiers()"); Classifiers result = null; try { result = _service.ListClassifiers(verbose: verbose); } catch (Exception e) { if (_listClassifiersRetries > 0) { _listClassifiersRetries--; ListClassifiers(verbose); } else { throw e; } } if (result != null) { Console.WriteLine("ListClassifiers() succeeded:\n{0}", JsonConvert.SerializeObject(result, Formatting.Indented)); } else { Console.WriteLine("Failed to ListClassifiers()"); } return(result); }
private void OnGetClassifiersResp(RESTConnector.Request req, RESTConnector.Response resp) { Classifiers classifiers = new Classifiers(); if (resp.Success) { try { fsData data = null; fsResult r = fsJsonParser.Parse(Encoding.UTF8.GetString(resp.Data), out data); if (!r.Succeeded) { throw new WatsonException(r.FormattedMessages); } object obj = classifiers; r = sm_Serializer.TryDeserialize(data, obj.GetType(), ref obj); if (!r.Succeeded) { throw new WatsonException(r.FormattedMessages); } } catch (Exception e) { Log.Error("NLC", "GetClassifiers Exception: {0}", e.ToString()); resp.Success = false; } } if (((GetClassifiersReq)req).Callback != null) { ((GetClassifiersReq)req).Callback(resp.Success ? classifiers : null); } }
/// <summary> /// Retrieve a list of custom classifiers. /// </summary> /// <param name="verbose">Specify `true` to return details about the classifiers. Omit this parameter to return a brief list of classifiers. (optional)</param> /// <returns><see cref="Classifiers" />Classifiers</returns> public Classifiers ListClassifiers(bool?verbose = null) { if (string.IsNullOrEmpty(VersionDate)) { throw new ArgumentNullException("versionDate cannot be null."); } Classifiers result = null; try { var request = this.Client.GetAsync($"{this.Endpoint}/v3/classifiers"); request.WithArgument("api_key", ApiKey); request.WithArgument("version", VersionDate); if (verbose != null) { request.WithArgument("verbose", verbose); } result = request.As <Classifiers>().Result; } catch (AggregateException ae) { throw ae.Flatten(); } return(result); }
public IEnumerable<DownloadEntry> GetDownloadsEntries(OperatingSystem os) { List<DownloadEntry> result = new List<DownloadEntry>(); if (os == OperatingSystem.OTHER || Classifiers == null) { result.Add(Artifact); return result; } result.Add(Artifact); string dictEntry; switch (os) { case OperatingSystem.WINDOWS: dictEntry = "natives-windows"; break; case OperatingSystem.LINUX: dictEntry = "natives-linux"; break; case OperatingSystem.MACOS: dictEntry = "natives-osx"; break; default: throw new ArgumentOutOfRangeException(nameof(os), os, null); } if (Classifiers.ContainsKey(dictEntry)) { Classifiers[dictEntry].IsNative = true; result.Add(Classifiers[dictEntry]); } else if (Classifiers.ContainsKey(dictEntry + (IntPtr.Size == 8 ? "-64" : "-32"))) { Classifiers[dictEntry + (IntPtr.Size == 8 ? "-64" : "-32")].IsNative = true; result.Add(Classifiers[dictEntry + (IntPtr.Size == 8 ? "-64" : "-32")]); } return result; }
private void StackPanel_MouseDown(object sender, MouseButtonEventArgs e) { Border border = (Border)((StackPanel)sender).Parent; if (isStackPanelSelected(border)) { border.BorderBrush = Brushes.White; Classifiers.Remove(((StackPanel)sender).Name); } else { int classifersCount = Classifiers.Count; if (classifersCount < 6) { border.BorderBrush = Brushes.Green; Classifiers.Add(((StackPanel)sender).Name); if (classifersCount + 1 == 6) { txtBlkInfo.Text = String.Format(DONEMSG, classifersCount + 1); } else { txtBlkInfo.Text = String.Format(ACTIVEMSG, classifersCount + 1, 6 - classifersCount); } } else { border.BorderBrush = Brushes.Red; txtBlkInfo.Text = DESELECTMSG; } } }
public void addClassifier(EClass classifier) { if (!ClassifierIDs.Contains(classifier.EaElement.ElementID)) { ClassifierIDs.Add(classifier.EaElement.ElementID); Classifiers.Add(classifier); } }
/// <summary> /// Edit the currently selected classifier (defined by the /// <seealso cref="SelectedIndex">SelectedIndex</seealso> /// property). /// <para> /// Private method that implements the <c>ICommand</c> <seealso cref="Edit"> /// Edit</seealso> through a <c>DelegateCommand</c>. /// </para> /// </summary> /// <param name="obj">Delegate object data - unused.</param> private void EditClassifier(object obj) { var classifier = Classifiers.ElementAt(SelectedIndex); if (classifier != null) { editClassifyingService.Edit(classifier); } }
/// <summary> /// Predicts the given Label from the object. /// </summary> /// <param name="o"></param> /// <returns></returns> public object Predict(object o) { var current = Generator.Descriptor.Convert(o, false).ToVector(); var predictions = Classifiers.Select(s => new Tuple <object, double>(s.Key, s.Value.PredictRaw(current))) .OrderByDescending(or => or.Item2).ToArray(); return(predictions.FirstOrDefault().Item1); }
private void OnGetClassifiers(Classifiers classifiers) { m_Refreshing = false; m_Classifiers = classifiers; foreach (var c in m_Classifiers.classifiers) { m_NLC.GetClassifier(c.classifier_id, OnGetClassifier); } }
private void btnClearAll_Click(object sender, RoutedEventArgs e) { foreach (String classifier in Classifiers) { Border border = getBorder(classifier); border.BorderBrush = Brushes.White; txtBlkInfo.Text = SELECTMSG; } Classifiers.Clear(); }
private void OnGetClassifiers(Classifiers classifiers, string data) { Log.Debug("ExampleNaturalLanguageClassifier", "Natural Language Classifier - GetClassifiers Response: {0}", data); foreach (Classifier classifier in classifiers.classifiers) { _classifierIds.Add(classifier.classifier_id); } _getClassifiersTested = true; }
private void OnGetClassifiers(Classifiers classifiers, Dictionary <string, object> customData) { Log.Debug("ExampleNaturalLanguageClassifier.OnGetClassifiers()", "Natural Language Classifier - GetClassifiers Response: {0}", customData["json"].ToString()); foreach (Classifier classifier in classifiers.classifiers) { _classifierIds.Add(classifier.classifier_id); } _getClassifiersTested = true; }
private void LoadKeywordClassifiers() { var data = new KeywordsSpreadsheet().LoadData().ToList(); data.ForEach(x => Classifiers.Save(x)); data.Single(x => x.SubCategory == SubCategories.HealthBeauty.DoctorsDentist) .AddKeyword(CompanyNames.StJohnOfGod.ToLowerInvariant()); data.Single(x => x.SubCategory == SubCategories.Kids.Childcare) .AddKeyword(CompanyNames.Kidz.ToLowerInvariant()); }
/// <summary> /// Edits the classifier. /// </summary> /// <returns>The classifier.</returns> /// <param name="id">Identifier.</param> public async Task <IActionResult> EditClassifier(int?id) { if (id != null) { Classifiers classifiers = await db.Classifiers.FirstOrDefaultAsync(p => p.id_class == id); if (classifiers != null) { return(View(classifiers)); } } return(NotFound()); }
public async Task <IActionResult> DeleteClassifier(int?id) { if (id != null) { Classifiers classifiers = new Classifiers { id_class = id.Value }; db.Entry(classifiers).State = EntityState.Deleted; await db.SaveChangesAsync(); return(RedirectToAction("Index")); } return(NotFound()); }
public void InsertClassifier(Classifiers ieraksts) { if (ieraksts.Id == 0) { db.InsertAsync(ieraksts).ContinueWith(t => { Console.WriteLine("New customer ID: {0}", ieraksts.Id); }); } else { db.UpdateAsync(ieraksts); } }
public void removeClassifier(EClass classifier) { EClass todelete = null; foreach (EClass eClass in Classifiers) { if (eClass.EaElement.ElementID == classifier.EaElement.ElementID) { todelete = eClass; } } Classifiers.Remove(todelete); ClassifierIDs.Remove(classifier.EaElement.ElementID); }
//[TestMethod] public void ListClassifiers_RC_Success() { Classifiers listClassifiersResult = null; try { listClassifiersResult = _service.ListClassifiers(); } catch { Assert.Fail("Failed to list classifier - out of retries!"); } Assert.IsNotNull(listClassifiersResult); }
public HttpResponseMessage SearchByXmlId(string xmlId, string domain, int langId, int siteLangId, int limit = 25) { try { // tmp fix for using terms with letters in the term service xmlId = new string(xmlId.Where(Char.IsDigit).ToArray()); } catch { } var classifierId = Classifiers.GetClassifierIdByXmlId(xmlId); return(SearchByClassifierId(classifierId, domain, langId, siteLangId, limit)); }
/// <summary> /// Move the currently selected classifier (defined by the /// <seealso cref="SelectedIndex">SelectedIndex</seealso> /// property) to earlier in the ordered list. /// <para> /// Private method that implements the <c>ICommand</c> <seealso cref="OrderEarlier"> /// OrderEarlier</seealso> through a <c>DelegateCommand</c>. /// </para> /// </summary> /// <param name="obj">Delegate object data - unused.</param> private void MoveItemUp(object obj) { if (selectedIndex != -1) { lock (this) { Debug.Assert(selectedIndex >= 0, "SelectedIndex must be valid, e.g. >= 0"); Debug.Assert(Classifiers.Count > 1, "Can only move item if more than one."); lock (Classifiers) { Classifiers.Swap(selectedIndex, selectedIndex - 1); } } } }
/// <summary> /// Retrieve a list of classifiers. /// </summary> /// <param name="verbose">Specify `true` to return details about the classifiers. Omit this parameter to return /// a brief list of classifiers. (optional)</param> /// <param name="customData">Custom data object to pass data including custom request headers.</param> /// <returns><see cref="Classifiers" />Classifiers</returns> public Classifiers ListClassifiers(bool?verbose = null, Dictionary <string, object> customData = null) { if (string.IsNullOrEmpty(VersionDate)) { throw new ArgumentNullException("versionDate cannot be null."); } Classifiers result = null; try { IClient client; if (_tokenManager == null) { client = this.Client; } else { client = this.Client.WithAuthentication(_tokenManager.GetToken()); } var restRequest = client.GetAsync($"{this.Endpoint}/v3/classifiers"); restRequest.WithArgument("version", VersionDate); if (verbose != null) { restRequest.WithArgument("verbose", verbose); } if (customData != null) { restRequest.WithCustomData(customData); } restRequest.WithHeader("X-IBMCloud-SDK-Analytics", "service_name=watson_vision_combined;service_version=v3;operation_id=ListClassifiers"); result = restRequest.As <Classifiers>().Result; if (result == null) { result = new Classifiers(); } result.CustomData = restRequest.CustomData; } catch (AggregateException ae) { throw ae.Flatten(); } return(result); }
public override void OnNavigatingTo(NavigationParameters parameters) { base.OnNavigatingTo(parameters); if (parameters.ContainsKey("Id")) { var id = (int)parameters["Id"]; if (id == 0) { Equipment = new Classifiers(); } else { Equipment = App.Database.GetClassifier(id); RaisePropertyChanged(nameof(Equipment)); } } }
/// <summary> /// Predict all given Labels across all classifiers for the current object. /// </summary> /// <param name="o"></param> /// <returns></returns> public IEnumerable <object> PredictClasses(object o) { var current = Generator.Descriptor.ToVector(o); var prediction = Classifiers.Select(s => new Tuple <object, double>(s.Key, s.Value.PredictRaw(current))) .OrderByDescending(or => or.Item2); var sum = prediction.Sum(s => s.Item2); foreach (var predict in prediction) { if (predict.Item2 >= 0.5) { yield return(predict.Item1); } } }
/// <summary> /// Retrieve a list of classifiers. /// </summary> /// <param name="verbose">Specify `true` to return details about the classifiers. Omit this parameter to return /// a brief list of classifiers. (optional)</param> /// <param name="customData">Custom data object to pass data including custom request headers.</param> /// <returns><see cref="Classifiers" />Classifiers</returns> public Classifiers ListClassifiers(bool?verbose = null, Dictionary <string, object> customData = null) { if (string.IsNullOrEmpty(VersionDate)) { throw new ArgumentNullException("versionDate cannot be null."); } Classifiers result = null; try { IClient client; if (_tokenManager == null) { client = this.Client; } else { client = this.Client.WithAuthentication(_tokenManager.GetToken()); } var restRequest = client.GetAsync($"{this.Endpoint}/v3/classifiers"); restRequest.WithArgument("version", VersionDate); restRequest.WithArgument("api_key", ApiKey); if (verbose != null) { restRequest.WithArgument("verbose", verbose); } if (customData != null) { restRequest.WithCustomData(customData); } result = restRequest.As <Classifiers>().Result; if (result == null) { result = new Classifiers(); } result.CustomData = restRequest.CustomData; } catch (AggregateException ae) { throw ae.Flatten(); } return(result); }
private void OnGetClassifiers(Classifiers classifiers) { if (classifiers != null) { foreach (var classifier in classifiers.classifiers) { if (!string.IsNullOrEmpty(m_ClassifierName) && !classifier.name.StartsWith(m_ClassifierName)) { continue; } if (classifier.language != m_Language) { continue; } m_NLC.GetClassifier(classifier.classifier_id, OnGetClassifier); } } }
private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e) { int selectedClassifiersCount = Classifiers.Count; if (selectedClassifiersCount < 6) { int missing = 6 - selectedClassifiersCount; List <StackPanel> panels = theGrid.Children.OfType <StackPanel>().ToList(); int index = 0; while (selectedClassifiersCount < 6) { var tempBorder = panels[index].Children.OfType <Border>().FirstOrDefault(); var stackPanel = (StackPanel)tempBorder.Child; Classifiers.Add(stackPanel.Name); index++; selectedClassifiersCount++; } } }