public async Task <IActionResult> PutErrorHistory(int id, ErrorHistory errorHistory) { if (id != errorHistory.Id) { return(BadRequest()); } _context.Entry(errorHistory).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ErrorHistoryExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <ActionResult <ErrorHistory> > PostErrorHistory(ErrorHistory errorHistory) { _context.ErrorHistory.Add(errorHistory); await _context.SaveChangesAsync(); return(CreatedAtAction("GetErrorHistory", new { id = errorHistory.Id }, errorHistory)); }
private static void AddRow(ErrCategory category, ErrLevel level, string factoryID, string shopID, string lotID, string productID, string productVer, string processID, string eqpID, string stepID, string reason, string detail ) { Outputs.ErrorHistory item = new ErrorHistory(); item.VERSION_NO = ModelContext.Current.VersionNo; item.ERR_CATEGORY = category.ToString(); item.ERR_LEVEL = level.ToString(); item.FACTORY_ID = factoryID; item.SHOP_ID = shopID; item.LOT_ID = lotID; item.PRODUCT_ID = productID; item.PRODUCT_VERSION = productVer; item.PROCESS_ID = processID; item.EQP_ID = eqpID; item.STEP_ID = stepID; item.ERR_REASON = reason; item.REASON_DETAIL = detail; OutputMart.Instance.ErrorHistory.Add(item); }
public async Task <ActionResult <Error> > PostError([FromBody] ErrorDto errorDto) { Error error = _mapper.Map <Error>(errorDto); error.Status = _context.Status.SingleOrDefault(s => s.Id == error.StatusId); error.Priority = _context.Priority.SingleOrDefault(p => p.Id == error.PriorityId); error.Impact = _context.Impact.SingleOrDefault(i => i.Id == error.ImpactId); error.User = _context.Users.SingleOrDefault(u => u.Id == error.UserId); error.DateCreated = DateTime.Now; _context.Error.Add(error); var errorHistory = new ErrorHistory { Error = error, Action = _context.Action.SingleOrDefault(a => a.Name == "Ввод"), Comment = "", User = error.User, Date = DateTime.Now }; _context.ErrorHistory.Add(errorHistory); await _context.SaveChangesAsync(); var err = _mapper.Map <ErrorDto>(error); return(CreatedAtAction("GetError", new { id = error.Id }, err)); }
public ActionResult Edit(ErrorHistory errorhistory) { if (ModelState.IsValid) { objErrorHistoryBO.UpdateErrorHistory(errorhistory); return(RedirectToAction("Index")); } return(View(errorhistory)); }
public static void WriteErrorHistory(ErrorLevel errorLevel, string reason) { ErrorHistory info = new ErrorHistory(); info.LEVEL = errorLevel.ToString(); info.REASON = reason; OutputMart.Instance.ErrorHistory.Add(info); }
public ActionResult Create(ErrorHistory errorhistory) { if (ModelState.IsValid) { objErrorHistoryBO.InsertErrorHistory(errorhistory); return(RedirectToAction("Index")); } return(View(errorhistory)); }
public void UpdateErrorHistory(ErrorHistory objErrorHistory) { try { context.Entry(objErrorHistory).State = EntityState.Modified; context.SaveChanges(); } catch (Exception ex) { throw ex; } }
public void DeleteErrorHistory(int errorHistoryId) { try { ErrorHistory objErrorHistory = context.ErrorHistories.Find(errorHistoryId); context.ErrorHistories.Remove(objErrorHistory); context.SaveChanges(); } catch (Exception ex) { throw ex; } }
// GET: /Admin/Error/Delete/5 public ActionResult Delete(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } ErrorHistory errorhistory = objErrorHistoryBO.GetErrorHistory(id.Value); if (errorhistory == null) { return(HttpNotFound()); } return(View(errorhistory)); }
public void InsertErrorHistory(ErrorHistory objErrorHistory) { try { objErrorHistory.ErrorLogTime = DateTime.Now; if (!string.IsNullOrEmpty(Helper.UserData)) { objErrorHistory.FKUserId = Helper.UserId; } context.ErrorHistories.Add(objErrorHistory); context.SaveChanges(); } catch (Exception ex) { throw ex; } }
public async Task <ActionResult <ErrorHistoryResponse> > Update(int id, [FromBody] ErrorHistoryItemRequest request) { var user = await db.Users.FirstOrDefaultAsync(x => x.Login == User.Identity.Name); var error = await db.Errors.FindAsync(id); if (error == null) { return(BadRequest("The is no error")); } if (error.State >= (Error.StateEnum)request.Action) { return(BadRequest($"State '{(Error.StateEnum)request.Action}' cannot become after '{error.State}'")); } var historyItem = new ErrorHistory { Date = DateTime.Now, Action = request.Action, Comment = request.Comment, UserId = user.Id, ErrorId = id }; error.State = (Error.StateEnum)historyItem.Action; db.ErrorHistory.Add(historyItem); db.Update(error); await db.SaveChangesAsync(); return(new ErrorHistoryResponse { Id = historyItem.Id, Date = historyItem.Date, Action = historyItem.Action, Comment = historyItem.Comment, User = new UserResponse { Name = user.Name, Surname = user.Surname } }); }
public async Task <ActionResult <ErrorPreviewResponse> > Create([FromBody] NewErrorRequest request) { var user = await db.Users.FirstOrDefaultAsync(x => x.Login == User.Identity.Name); var error = new Error { CreateDate = DateTime.Now, ShortDescription = request.ShortDescription, Description = request.Description, State = Error.StateEnum.New, Urgency = request.Urgency, Criticality = request.Criticality }; db.Errors.Add(error); await db.SaveChangesAsync(); var firstHistoryItem = new ErrorHistory { Date = DateTime.Now, Action = ErrorHistory.ActionEnum.Input, Comment = "Init", UserId = user.Id, ErrorId = error.Id }; db.ErrorHistory.Add(firstHistoryItem); await db.SaveChangesAsync(); return(new ErrorPreviewResponse { Id = error.Id, CreateDate = error.CreateDate, ShortDescription = error.ShortDescription, State = error.State, Urgency = error.Urgency, Criticality = error.Criticality }); }
/// <summary> /// Treains the neural network over a given number of epochs using backpropagation. /// </summary> /// <param name="epochs">THe number of iterations to which the neural network will train before failing.</param> /// <param name="minimumError">The minimum error which the network must reach to </param> /// <param name="learningRate">The learning rate at which the network will begin to learn.</param> /// <param name="momentum">The momentum at which the network will begin to learn.</param> /// <param name="nudging">Enables nudging of the neural network during training.</param> /// <returns>Whether or not the network was successful in learning.</returns> public int Train(int epochs, double minimumError, bool nudging = false, params double[] learningParameters) { ErrorHistory.Clear(); int epoch = 0; double error = 0; do { epoch++; //Train online or perform batch training if (online) { error = trainingSet.Select( dp => network.Train(dp, learningParameters)) .Sum(); } else { error = network.Train(trainingSet, learningParameters); } this.ErrorHistory.Add(error); //NUDGING if (nudging && ErrorHistory .SkipWhile(i => i < ErrorHistory.Count() - 10) .StdDev() < .0000075) { network.NudgeWeights(); //Nudge the weights } #if DEBUG Console.WriteLine("Epoch {0}: Error = {1};", epoch, error); #endif }while (epoch < epochs && error > minimumError); return(epoch); }
public double train(TrainingTemplate trainingTemplate, int extMaxGenerations, ErrorHistory errorProg) { //This is simple but the ideea is suposed to be that in larger networks here I do a foreach over the neurons double error = this.trainingMethod.trainNetwork(trainingTemplate, perceptron, extMaxGenerations, errorProg); return(error); }
public void OnException(ExceptionContext filterContext) { var area = "";//todo.... var controller = (filterContext.RouteData.Values["controller"] ?? "").ToString(); var action = (filterContext.RouteData.Values["action"] ?? "").ToString(); //səbəbkar erroru tapmaq while (filterContext.Exception.InnerException != null) { filterContext.Exception = filterContext.Exception.InnerException; } var model = new HandleErrorInfo(filterContext.Exception, controller, action); try { using (var db = new CvDbContext()) { var entity = new ErrorHistory(); if (!string.IsNullOrWhiteSpace(area)) { entity.AreaName = area; } if (!string.IsNullOrWhiteSpace(controller)) { entity.ControllerName = controller; } if (!string.IsNullOrWhiteSpace(action)) { entity.ActionName = action; } if (filterContext.Exception is HttpException) { entity.ErrorCode = (filterContext.Exception as HttpException).GetHttpCode(); } else if (filterContext.Exception is SqlException) { entity.ErrorCode = (filterContext.Exception as SqlException).Number; entity.ErrorMessage = filterContext.Exception.Message; } else { entity.ErrorMessage = filterContext.Exception.Message; } logger.Fatal(entity.ErrorMessage); entity.CreatedDate = DateTime.Now; db.ErrorHistories.Add(entity); db.SaveChanges(); } } catch (Exception) { //logger.Fatal(ex) } filterContext.Result = new ViewResult { ViewName = "~/Views/Home/ErrorPage.cshtml", //MasterName = "~/Views/Shared/_Layout.cshtml", ViewData = new ViewDataDictionary <HandleErrorInfo>(model), TempData = filterContext.Controller.TempData }; filterContext.ExceptionHandled = true; }
public async Task <IActionResult> PutError(int id, ErrorDto errorDto) { var errorBf = _context.Error.SingleOrDefault(e => e.Id == id); var prevStatus = errorBf.Status; var error = _mapper.Map <Error>(errorDto); var status = _context.Status.SingleOrDefault(s => s.Id == errorDto.StatusId); if (id != error.Id) { return(BadRequest()); } var action = new Models.Action(); // check statuses if (prevStatus.Name != status.Name) { if (prevStatus.Name == ErrorStatusTypes.New && status.Name != ErrorStatusTypes.Opened) { return(BadRequest()); } if (prevStatus.Name == ErrorStatusTypes.Opened && status.Name != ErrorStatusTypes.Solved) { return(BadRequest()); } if (prevStatus.Name == ErrorStatusTypes.Solved && (status.Name != ErrorStatusTypes.Opened && status.Name != ErrorStatusTypes.Closed)) { return(BadRequest()); } if (prevStatus.Name == ErrorStatusTypes.Closed) { return(BadRequest()); } if (status.Name == ErrorStatusTypes.Opened) { action = _context.Action.SingleOrDefault(a => a.Name == "Открытие"); } if (status.Name == ErrorStatusTypes.Solved) { action = _context.Action.SingleOrDefault(a => a.Name == "Решение"); } if (status.Name == ErrorStatusTypes.Closed) { action = _context.Action.SingleOrDefault(a => a.Name == "Закрытие"); } // all good var errorHistory = new ErrorHistory { Error = error, Action = action, Comment = error.ErrorHistory.ToList()[error.ErrorHistory.Count - 1].Comment, User = _context.Users.SingleOrDefault(u => u.Id == errorDto.UserId), Date = DateTime.Now }; _context.ErrorHistory.Add(errorHistory); } var entry = _context.Entry(error); entry.Property(e => e.ShortDesc).IsModified = true; entry.Property(e => e.Description).IsModified = true; entry.Property(e => e.PriorityId).IsModified = true; entry.Property(e => e.ImpactId).IsModified = true; entry.Property(e => e.StatusId).IsModified = true; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ErrorExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> Update(editClass ed) { err err1 = await db.Errors.FirstOrDefaultAsync(p => p.id == ed.Err.id); string a = Request.Form["status"].ToString(); if (err1.statusId != 4) { if (a == "Открытая") { Models.Status st = await db.Statuses.FirstOrDefaultAsync(p => p.id == 2); err1.status = st; } if (a == "Решенная") { Models.Status st = await db.Statuses.FirstOrDefaultAsync(p => p.id == 3); err1.status = st; } if (a == "Закрытая") { Models.Status st = await db.Statuses.FirstOrDefaultAsync(p => p.id == 4); err1.status = st; } ErrorHistory e = new ErrorHistory(); if (a == "Открытая") { e.act = "Открытие"; } if (a == "Решенная") { e.act = "Решение"; } if (a == "Закрытая") { e.act = "Закрытие"; } ed.Err.user_id = User.Identity.Name; e.errId = ed.Err.id; if (ed.buf != null && err1.status != null) { e.comnt = ed.buf; } e.date = DateTime.Now; e.user_id = ed.Err.user_id; db.ErHstr.Add(e); db.Errors.Update(err1); await db.SaveChangesAsync(); return(RedirectToAction("Index", "Home")); } return(RedirectToAction("Index", "Home")); }
public double train(TrainingTemplate trainingTemplate, int extMaxGenerations, ErrorHistory errorProg) { //Note to self 0.1 is right out of my ass return(trainer.trainNetwork(trainingTemplate, inputLayer, outputLayer, hiddenLayer, extMaxGenerations, 0.1, errorProg)); }
private void button1_Click(object sender, EventArgs e) { neuron = new Neuron("AND-Neuron", 0, 2); neuron.addNewInput("input1", 0, 0); neuron.addNewInput("input2", 0, 0); PerceptronNetwork pn = new PerceptronNetwork(neuron); TrainingTemplate andTemplate = new TrainingTemplate("AND Template"); andTemplate.addTrainingRow(new TrainingRow(new List <double> { 0, 0 }, new List <double> { 0 })); andTemplate.addTrainingRow(new TrainingRow(new List <double> { 0, 1 }, new List <double> { 0 })); andTemplate.addTrainingRow(new TrainingRow(new List <double> { 1, 0 }, new List <double> { 0 })); andTemplate.addTrainingRow(new TrainingRow(new List <double> { 1, 1 }, new List <double> { 1 })); TrainingTemplate orTemplate = new TrainingTemplate("OR Template"); orTemplate.addTrainingRow(new TrainingRow(new List <double> { 0, 0 }, new List <double> { 0 })); orTemplate.addTrainingRow(new TrainingRow(new List <double> { 0, 1 }, new List <double> { 1 })); orTemplate.addTrainingRow(new TrainingRow(new List <double> { 1, 0 }, new List <double> { 1 })); orTemplate.addTrainingRow(new TrainingRow(new List <double> { 1, 1 }, new List <double> { 1 })); TrainingTemplate xorTemplate = new TrainingTemplate("XOR Template"); xorTemplate.addTrainingRow(new TrainingRow(new List <double> { 0, 0 }, new List <double> { 0 })); xorTemplate.addTrainingRow(new TrainingRow(new List <double> { 0, 1 }, new List <double> { 1 })); xorTemplate.addTrainingRow(new TrainingRow(new List <double> { 1, 0 }, new List <double> { 1 })); xorTemplate.addTrainingRow(new TrainingRow(new List <double> { 1, 1 }, new List <double> { 0 })); templatesList = new List <TrainingTemplate>(); ErrorHistory errorProg = new ErrorHistory(); double error = pn.train(xorTemplate, 100, errorProg); labelWeight1.Text = neuron.inputs[0].weight.ToString("N3"); labelWeight2.Text = neuron.inputs[1].weight.ToString("N3"); labelError.Text = error.ToString("N3"); for (int X = 0; X < errorProg.errorPoints.Count; X++) { chart1.Series["Error"].Points.AddXY(X, errorProg.errorPoints[X]); } //chart1.DataBind(errorProg); }