public TrainModel(FeatureExtractionType eType, int EuclideanCentroidPointIndex, ClassifierType cType) { this.cType = cType; Trained = false; if (eType == FeatureExtractionType.EuclideanDistance) featureExtraction = new EuclideanDistance(EuclideanCentroidPointIndex); }
// todo: parent group or item should be edited outside classifier fields private static ICollection <FieldMetadata> GetCommonFields(ClassifierType type) { if (type.HierarchyType == HierarchyType.Groups) { return(new List <FieldMetadata> { new ClassifierGroupField { Key = "parentUid", Name = "Группа", Required = true, Props = { TypeCode = type.Code, TreeCode = ClassifierTree.DefaultCode } } }); } if (type.HierarchyType == HierarchyType.Items) { return(new List <FieldMetadata> { new ClassifierGroupField { Key = "parentUid", Name = "Родительский элемент", Props = { TypeCode = type.Code } }, }); } return(null); }
private async Task <DataView> GetClassifierForm(ClassifierType type, CancellationToken cancellationToken) { var metadata = await _metadataRepository.Search(new MetadataSearchRequest { EntityTypeCode = ClassifierType.TypeCode, EntityUid = type.Uid, IsActive = true }, cancellationToken); var result = new DataView { Fields = metadata.Rows }; foreach (var field in result.Fields) { if (field.System == false) { field.Key = FieldKey.FormatFullKey(field.Key); } } var commonFields = GetCommonFields(type); if (commonFields != null) { result.Fields = commonFields.Union(result.Fields).ToArray(); } return(result); }
protected override async Task <SearchResult <Classifier> > SearchInternal(DbContext db, ClassifierType type, ClassifierSearchRequest request, CancellationToken cancellationToken) { var classifiers = BuildQuery(db, type, request); var dbMessageTemplates = db.GetTable <DbMessageTemplate>().AsQueryable(); var joined = from classifier in classifiers join dbMessageTemplate in dbMessageTemplates on classifier.Uid equals dbMessageTemplate.Uid select new DbItem { Classifier = classifier, MessageTemplate = dbMessageTemplate }; // todo: fix paging - map column to expression request.SortColumn ??= nameof(Classifier.Code); request.SortColumn = nameof(DbItem.Classifier) + "." + request.SortColumn; var data = await joined .Apply(request, x => x.Classifier.Code) .Select(x => Materialize(type, x)) .Cast <Classifier>() .ToListAsync(cancellationToken); return(new SearchResult <Classifier> { TotalCount = joined.GetTotalCount(request), Rows = data }); }
public static ImageClassifier GetClassifier(ClassifierType type) { string protoTxtPath = string.Empty; string mdlBinPath = string.Empty; switch (type) { case ClassifierType.Resnet: { protoTxtPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "resnet_nsfw.prototxt"); mdlBinPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "resnet_50_1by2_nsfw.caffemodel"); } break; case ClassifierType.Squeezenet: { protoTxtPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "squeezenet_nsfw.prototxt"); mdlBinPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "squeezenet_nsfw.caffemodel"); } break; } var classifier = new ImageClassifier(protoTxtPath, mdlBinPath, type); if (classifier.IsEmpty) { throw new Exception("Classifier shouldn't be empty. Are you model paths correct?"); } return(classifier); }
public Classifier_(String name, ClassifierType type) { this.name = name; this.classifierType = type; this.methods = new List<Method_>(); this.fields = new List<Field_>(); }
protected virtual async Task <ApiResult> UpdateInternal( DbContext db, ClassifierType type, ClassifierTree tree, Classifier item, CancellationToken cancellationToken = default) { var validator = new ClassifierValidator(db, type); if (await validator.ValidateUpdate(item, cancellationToken) == false) { return(new ApiResult { Success = false, Errors = validator.Errors }); } var affected = await db.GetTable <DbClassifier>() .Where(x => x.Uid == item.Uid) .Set(x => x.Code, item.Code) .Set(x => x.Name, item.Name) .Set(x => x.ParentUid, type.HierarchyType == HierarchyType.Items ? item.ParentUid : null) .Set(x => x.IsActive, item.IsActive) .UpdateAsync(cancellationToken); var result = await UpdateHierarchy(db, type, tree, item, cancellationToken); if (result.Success == false) { return(result); } return(new ApiResult { AffectedRows = affected }); }
public TrainModel(FeatureExtractionType eType, ClassifierType cType) { this.cType = cType; Trained = false; if (eType == FeatureExtractionType.EuclideanDistance) featureExtraction = new EuclideanDistance(14); }
public static RegisterClassifierType GetDefaultMetadata() { return(new() { Item = new ClassifierType { Code = ClassifierTypeCode.MessageTemplate, Name = "Message templates", HierarchyType = HierarchyType.Groups, IsSystem = true }, Fields = new List <FieldMetadata> { new TextField { Key = "code", Name = "Code", Required = true, DisplayOrder = 10, System = true }, new TextAreaField { Key = "name", Name = "Name", Required = true, DisplayOrder = 20, System = true, Props = new TextAreaField.Properties { Rows = 5 } }, new TextField { Key = "subject", Name = "Subject", DisplayOrder = 30, System = true }, // todo: make markdown/html editor control new TextAreaField { Key = "body", Name = "Body", DisplayOrder = 40, System = true, Props = new TextAreaField.Properties { Rows = 40 } } } }); }
protected override async Task <ApiResult> DeleteInternal(DbContext db, ClassifierType type, DeleteClassifier request, CancellationToken cancellationToken = default) { await db.GetTable <DbNumerator>() .Where(x => request.Uids.Contains(x.Uid)) .DeleteAsync(cancellationToken); return(await base.DeleteInternal(db, type, request, cancellationToken)); }
public TrainModel(FeatureExtractionType eType, ClassifierType cType) { this.cType = cType; Trained = false; if (eType == FeatureExtractionType.EuclideanDistance) { featureExtraction = new EuclideanDistance(14); } }
private static DataView GetClassifierTabs(ClassifierType type) { var panes = new List <DataPane> { new() { Key = "info", Name = "Информация", Icon = "profile", Component = "panes/TabEditClassifier" }, new() { Key = "hierarchy", Name = "Иерархия", Component = "panes/TabEditClassifierHierarchy" }, new() { Key = "dependencies", Name = "Зависимости" }, new() { Key = "history", Name = "История изменений", Icon = "eye" } }; // todo: register different tabs for different classifiers on startup if (type.Code == "questionnaire") { panes.Insert(panes.FindIndex(x => x.Key == "info") + 1, new DataPane { Key = "questionnaire", Name = "Вопросы", Component = "panes/PaneSearchMetadata" }); } if (type.Code == "numerator") { panes.Insert(panes.FindIndex(x => x.Key == "info") + 1, new DataPane { Key = "usage", Name = "Использование", Component = "panes/TabEditNumeratorEntities" }); } if (type.Code == "role") { panes.Insert(panes.FindIndex(x => x.Key == "info") + 1, new DataPane { Key = "permissions", Name = "Permissions", Component = "components/tab-edit-role-permissions" }); } if (type.Code == "user") { panes.Insert(panes.FindIndex(x => x.Key == "info") + 1, new DataPane { Key = "roles", Name = "Roles", Icon = "solution", Component = "components/tab-edit-user-roles" }); } // todo: move to own module if (type.Code == "process") { panes.Insert(panes.FindIndex(x => x.Key == "info") + 1, new DataPane { Key = "steps", Name = "Шаги", Component = "panes/PaneProcessStepList" }); } return(new DataView { Panes = panes }); }
public ClosureTableHandler(DbContext db, ClassifierType type) { if (type.HierarchyType == HierarchyType.None) { throw new InvalidOperationException($"Hierarchy type {type.HierarchyType} is not suitable to build closure table."); } _db = db; _type = type; }
protected override async Task <ApiResult> DeleteInternal(DbContext db, ClassifierType type, DeleteClassifier request, CancellationToken cancellationToken = default) { // todo: validate template is not used await db.GetTable <DbMessageTemplate>() .Where(x => request.Uids.Contains(x.Uid)) .DeleteAsync(cancellationToken); return(await base.DeleteInternal(db, type, request, cancellationToken)); }
private MessageTemplate Materialize(ClassifierType type, DbItem dbItem) { var item = base.Materialize(type, dbItem.Classifier); var dbMessageTemplate = dbItem.MessageTemplate; item.Subject = dbMessageTemplate.Subject; item.Body = dbMessageTemplate.Body; return(item); }
public static ClassifierParams Create(ClassifierType type, ClassificationAlgorithmType algorithmType, string targetTag) { return new ClassifierParams { Type = type, TargetTag = targetTag, SamplingParams = new SamplingParams { NeedSampling = false }, ClassificationAlgorithmParams = new ClassificationAlgorithmParams { Type = algorithmType}, FeatureSelectionParams = new FeatureSelectionParams {Type = FeatureSelectorType.Unknown } }; }
public DeviceInformation(string serial, MyoPose pose, ClassifierType classifier, byte classifierIndex, bool customClassifier, byte streamIndicating, DeviceType device) { this.SerialNumber = serial; this.UnlockPose = pose; this.ActiveClassifierType = classifier; this.ActiveClassifierIndex = classifierIndex; this.HasCustomClassifier = customClassifier; this.StreamIndicating = streamIndicating; this.Device = device; }
private ISentimentClassifier GetClassifier(ClassifierType type) { switch (type) { case ClassifierType.MaxEnt: return new MaxEntSentimentClassifier(); case ClassifierType.Alchemy: return new AlchemySentimentClassifier(); } return null; }
public DeviceInformation (string serial, MyoPose pose, ClassifierType classifier, byte classifierIndex, bool customClassifier, byte streamIndicating, DeviceType device) { this.SerialNumber = serial; this.UnlockPose = pose; this.ActiveClassifierType = classifier; this.ActiveClassifierIndex = classifierIndex; this.HasCustomClassifier = customClassifier; this.StreamIndicating = streamIndicating; this.Device = device; }
private static async Task <SearchResult <ClassifierGroup> > GetGroupsByFocus(DbContext db, ClassifierType type, ClassifierTree tree, ClassifierGroupSearchRequest request, CancellationToken cancellationToken) { // get all parent uids of focused item var path = await( from focus in db.GetTable <DbClassifierGroup>() join closureUp in db.GetTable <DbClassifierClosure>() on focus.Uid equals closureUp.ChildUid join item in db.GetTable <DbClassifierGroup>() on closureUp.ParentUid equals item.Uid where /*focus.TypeUid == type.Uid &&*/ focus.Uid == request.FocusUid orderby closureUp.Level descending select item.ParentUid) .ToListAsync(cancellationToken); SearchResult <ClassifierGroup> result = null; List <ClassifierGroup> currentLevel = null; foreach (var parentUid in path) { if (parentUid == request.ParentUid) { // found requested parent, init result and starting level result = new SearchResult <ClassifierGroup> { Rows = currentLevel = new List <ClassifierGroup>() }; } // if current level is not already inited if (currentLevel == null) { continue; } // try to move to deeper level... if (parentUid.HasValue) { var parent = currentLevel.SingleOrDefault(x => x.Uid == parentUid); if (parent != null) { parent.Children = currentLevel = new List <ClassifierGroup>(); } } // ... and load children var chldrn = await GetGroupsByParent(db, type, tree, parentUid, request, false); currentLevel.AddRange(chldrn.Rows); } return(result); }
private Numerator Materialize(ClassifierType type, DbItem dbItem) { var item = base.Materialize(type, dbItem.Classifier); var dbNumerator = dbItem.Numerator; item.EntityTypeCode = dbNumerator.EntityTypeCode; item.Periodicity = Enum.Parse <NumeratorPeriodicity>(dbNumerator.Periodicity); item.Pattern = dbNumerator.Pattern; item.KeyTags = dbNumerator.KeyTags?.Split(DbNumerator.KeyTagsSeparator, StringSplitOptions.RemoveEmptyEntries); return(item); }
private User Materialize(ClassifierType type, DbItem dbItem) { var item = base.Materialize(type, dbItem.Classifier); var dbUser = dbItem.User; item.UserName = dbUser.UserName; item.FirstName = dbUser.FirstName; item.LastName = dbUser.LastName; item.PhoneNumber = dbUser.PhoneNumber; item.Email = dbUser.Email; return(item); }
public static RegisterClassifierType GetDefaultMetadata() { return(new() { Item = new ClassifierType { Code = ClassifierTypeCode.Role, Name = "Roles", HierarchyType = HierarchyType.Groups, IsSystem = true }, Fields = ClassifierMetadata.GetDefaultFields().ToList() }); }
public async Task <IList <FieldMetadata> > GetMetadata(ClassifierType type, CancellationToken cancellationToken) { var metadata = await _fieldMetadataRepository.Search(new MetadataSearchRequest { EntityTypeCode = ClassifierType.TypeCode, EntityUid = type.Uid, // todo: check flags // IsSystem = false, IsActive = true, SkipPaging = true }, cancellationToken); return(metadata.Rows); }
private async Task <ApiResult> InsertHierarchy( DbContext db, ClassifierType type, Classifier item, CancellationToken cancellationToken) { if (type.HierarchyType == HierarchyType.Groups) { // todo: validate group belongs to the same classifier // todo: validate selected group belong to default tree // what if insert classifier and no groups inserted before? /*if (request.TreeUid == null || request.ParentUid == null) * { * throw new InvalidOperationException("Classifier should belong to one of the default hierarchy group."); * }*/ // todo: should be linked to at least one main group? if (/*request.TreeUid != null &&*/ item.ParentUid != null) { // link to selected group await db.GetTable <DbClassifierLink>() .Value(x => x.GroupUid, item.ParentUid) .Value(x => x.ItemUid, item.Uid) .InsertAsync(cancellationToken); } // if group is not of default hierarchy, link to default hierarchy root /*var root = await GetRoot(db, request.ParentUid.Value, cancellationToken); * * if (root.Code != ClassifierTree.DefaultCode) * { * await LinkToDefaultRoot(db, type, itemUid, cancellationToken); * }*/ } else if (type.HierarchyType == HierarchyType.Items) { var closureTable = new ClosureTableHandler(db, type); // ReSharper disable once PossibleInvalidOperationException if (await closureTable.Insert(item.Uid.Value, item.ParentUid, cancellationToken) == false) { return(new ApiResult { Success = false, Errors = closureTable.Errors }); } } return(new ApiResult()); }
public ClassifierTypeDto(ClassifierType classifierType, bool addClassifiers = true, bool addRelationships = true) { Code = classifierType.Code; Name = classifierType.Name; Description = classifierType.Description; UpdatedBy = classifierType.UpdatedBy; UpdatedOn = classifierType.UpdatedOn; if (addClassifiers) { foreach (Classifier classifier in classifierType.GetMembers()) { members.Add(new ClassifierDto(classifier, addRelationships)); } } }
public KFoldCrossValidation(List <Data> data, int k_fold, ClassifierType cType, FeatureExtractionType fType, int K = 3) { Kfold = k_fold; this.K = K; this.cType = cType; this.fType = fType; Data = data; r = new Random(); chunckSize = new List <int>(Kfold); for (int i = 0; i < Kfold - 1; ++i) { chunckSize.Add(Data.Count / Kfold); } chunckSize.Add(Data.Count - ((Kfold - 1) * (Data.Count / Kfold))); }
protected T Materialize(ClassifierType type, DbClassifier dbItem) { return(new T { Type = type.Code, Uid = dbItem.Uid, StatusCode = dbItem.StatusCode, Code = dbItem.Code, Name = dbItem.Name, IsActive = dbItem.IsActive, IsSystem = dbItem.IsSystem, ParentUid = dbItem.ParentUid, Url = $"/classifiers/{type.Code}/edit/{dbItem.Uid}" }); }
private void rbClassifier_CheckChanged(object sender, EventArgs e) { var rb = sender as RadioButton; if (rb != null) { if (rb.Checked) { this._LastClassifierType = (ClassifierType)rb.Tag; this.LoadData(); this.nudDecisionTreeDepth.Enabled = false; this.nudForestTrees.Enabled = false; this.nudRepetitions.Enabled = false; this.nudBoosts.Enabled = false; this.nudK.Enabled = false; switch (this._LastClassifierType) { case ClassifierType.DecisionTree: this.nudDecisionTreeDepth.Enabled = true; break; case ClassifierType.RandomForest: this.nudDecisionTreeDepth.Enabled = true; this.nudForestTrees.Enabled = true; this.nudRepetitions.Enabled = true; break; case ClassifierType.AdaBoostStump: this.nudBoosts.Enabled = true; break; case ClassifierType.AdaBoostTree: this.nudBoosts.Enabled = true; this.nudDecisionTreeDepth.Enabled = true; break; case ClassifierType.kNN: this.nudK.Enabled = true; break; } Properties.Settings.Default.ClassifierType = (int)rb.Tag; Properties.Settings.Default.Save(); } } }
protected override async Task <ApiResult> InsertInternal(DbContext db, ClassifierType type, Classifier item, CancellationToken cancellationToken = default) { var result = await base.InsertInternal(db, type, item, cancellationToken); if (result.Success) { // var numerator = (Numerator)item; await db.GetTable <DbDocumentType>() .Value(x => x.Uid, item.Uid) .InsertAsync(cancellationToken); } return(result); }
/// <summary> /// Filter by all parameters except FocusUid /// </summary> protected virtual async Task <SearchResult <Classifier> > SearchInternal(DbContext db, ClassifierType type, ClassifierSearchRequest request, CancellationToken cancellationToken) { var query = BuildQuery(db, type, request); var data = await query .Apply(request, x => x.Code) .Select(x => Materialize(type, x)) .Cast <Classifier>() .ToListAsync(cancellationToken); return(new SearchResult <Classifier> { TotalCount = query.GetTotalCount(request), Rows = data }); }
protected override async Task <ApiResult> UpdateInternal(DbContext db, ClassifierType type, ClassifierTree tree, Classifier item, CancellationToken cancellationToken = default) { var result = await base.UpdateInternal(db, type, tree, item, cancellationToken); /*if (result.Success) * { * var numerator = (Numerator)item; * * await db.GetTable<DbDocumentType>() * .Where(x => x.Uid == item.Uid) * .Set(x => x.Pattern, numerator.Pattern) * .UpdateAsync(cancellationToken); * }*/ return(result); }
public async Task <ApiResult> Register(ClassifierType item, ICollection <FieldMetadata> fields, CancellationToken cancellationToken) { var type = await _classifierTypeService.TryGet(item.Code, cancellationToken); // todo: compare fields of registered classifier and fields from parameters to update them in db if (type != null) { _logger.LogDebug("Classifier type {code} already registered.", item.Code); return(new ApiResult { AffectedRows = 0 }); } // todo: register numerator (get default from settings) using (var scope = _unitOfWorkFactory.Create()) { var insertTypeResult = await _classifierTypeService.Insert(item, cancellationToken); insertTypeResult.AssertSuccess(() => $"Failed to register classifier type \"{item.Code}\""); // todo: throw if empty fields or get default fields? if (fields != null) { var insertFieldResult = await _metadataService.Insert(new ManageFieldMetadataRequest { EntityTypeCode = ClassifierType.TypeCode, // ReSharper disable once PossibleInvalidOperationException EntityUid = insertTypeResult.Uid.Value, Items = fields }, cancellationToken); insertFieldResult.AssertSuccess(() => $"Failed to register classifier type \"{item.Code}\""); } scope.Commit(); _logger.LogInformation("Classifier type {code} successfully registered.", item.Code); return(new ApiResult { AffectedRows = 1, Uid = insertTypeResult.Uid }); } }
protected override async Task <SearchResult <Classifier> > SearchInternal(DbContext db, ClassifierType type, ClassifierSearchRequest request, CancellationToken cancellationToken) { var classifiers = BuildQuery(db, type, request); var numerators = db.GetTable <DbNumerator>().AsQueryable(); var numeratorRequest = request as NumeratorSearchRequest; if (numeratorRequest?.EntityTypeCode != null && numeratorRequest.EntityTypeUid != null) { var numeratorEntities = db.GetTable <DbNumeratorEntity>().Where(x => x.EntityUid == numeratorRequest.EntityTypeUid); if (numeratorRequest.IsAutoNumbering != null) { numeratorEntities = numeratorEntities.Where(x => x.IsAutoNumbering == numeratorRequest.IsAutoNumbering); } numerators = from n in numerators.Where(x => x.EntityTypeCode == numeratorRequest.EntityTypeCode) join ne in numeratorEntities on n.Uid equals ne.NumeratorUid select n; } var joined = from classifier in classifiers join numerator in numerators on classifier.Uid equals numerator.Uid select new DbItem { Classifier = classifier, Numerator = numerator }; // todo: fix paging - map column to expression request.SortColumn ??= nameof(Classifier.Code); request.SortColumn = nameof(DbItem.Classifier) + "." + request.SortColumn; var data = await joined .Apply(request, x => x.Classifier.Code) .Select(x => Materialize(type, x)) .Cast <Classifier>() .ToListAsync(cancellationToken); return(new SearchResult <Classifier> { TotalCount = joined.GetTotalCount(request), Rows = data }); }
private async Task ValidateDuplicateCode(ClassifierType item, CancellationToken cancellationToken) { var duplicate = await _db.GetTable <DbClassifierType>() .Where(x => x.Uid != item.Uid && x.Code == item.Code) .FirstOrDefaultAsync(cancellationToken); if (duplicate != null) { Errors.Add(new ApiResultError { Key = "code", Messages = new[] { $"Код «{duplicate.Code}» уже используется в классификаторе «{duplicate.Name}»." } }); } }
protected override async Task <ApiResult> UpdateInternal(DbContext db, ClassifierType type, ClassifierTree tree, Classifier item, CancellationToken cancellationToken = default) { var result = await base.UpdateInternal(db, type, tree, item, cancellationToken); if (result.Success) { var template = (MessageTemplate)item; await db.GetTable <DbMessageTemplate>() .Where(x => x.Uid == item.Uid) .Set(x => x.Subject, template.Subject) .Set(x => x.Body, template.Body) .UpdateAsync(cancellationToken); } return(result); }
private string GetFileNameFromClassifierType(ClassifierType classifierType) { string classifierFileName = string.Empty; switch (this.ClassifierType) { case ClassifierType.Eyes: classifierFileName = "haarcascade_eye.xml"; break; case ClassifierType.Front: classifierFileName = "haarcascade_frontalface_default.xml"; break; case ClassifierType.ProfileFace: classifierFileName = "haarcascade_profileface.xml"; break; case ClassifierType.FullBody: classifierFileName = "haarcascade_fullbody.xml"; break; case ClassifierType.UpperBody: classifierFileName = "haarcascade_upperbody.xml"; break; case ClassifierType.LowerBody: classifierFileName = "haarcascade_lowerbody.xml"; break; } classifierFileName = System.IO.Path.Combine(this.ClassifierDir.FullName, classifierFileName); return classifierFileName; }
private void InitClassifiers(ClassifierType classifierType, System.IO.DirectoryInfo classifierDir) { string faceClassifierFileName = GetFileNameFromClassifierType(classifierType); string eyesClassifierFileName = GetFileNameFromClassifierType(ClassifierType.Eyes); managedHaarFace = HaarClassifierCascade.Parse(XDocument.Load(faceClassifierFileName)); managedHaarEyes = HaarClassifierCascade.Parse(XDocument.Load(eyesClassifierFileName)); unmanagedHaarFace = new HaarCascade(faceClassifierFileName); unmanagedHaarEyes = new HaarCascade(eyesClassifierFileName); }
public FaceDetector(ClassifierType classifierType, System.IO.DirectoryInfo classifierDir) { this.classifierType = classifierType; this.ClassifierDir = classifierDir; InitClassifiers(classifierType, classifierDir); }
public JsonResult SetClassifier(ClassifierType type) { ClassifierType = type; return Json(new { }); }
public static extern IntPtr imaqReadClassifierFile(ref IntPtr session, [MarshalAs(UnmanagedType.LPStr)] string fileName, ReadClassifierFileMode mode, ref ClassifierType type, ref ClassifierEngineType engine, String255 description);
public static extern IntPtr imaqCreateClassifier(ClassifierType type);