public JsonResult LossTypeUp(LossType models)
{
bool status = false;
if (models != null)
{
var data = db.LossTypes.FirstOrDefault(x => x.Id == models.Id);
if (data != null)
{
data.LossTypeName = models.LossTypeName;
data.IsActive = models.IsActive;
data.CreateBy = User.Identity.Name;
data.CreateTime = DateTime.Now;
try
{
db.SaveChanges();
status = true;
}
catch (Exception ex)
{
ex.ToString();
}
}
}
return(Json(status, JsonRequestBehavior.AllowGet));
}
public JsonResult LossTypeAdd(LossType models)
{
int status = 0;
if (models != null)
{
var checkData = db.LossTypes.FirstOrDefault(x => x.Id == models.Id);
if (checkData != null)
{
status = -1;
}
LossType lossType = new LossType();
lossType.LossTypeName = models.LossTypeName;
lossType.IsActive = models.IsActive;
lossType.CreateBy = User.Identity.Name;
lossType.CreateTime = DateTime.Now;
try
{
db.LossTypes.Add(lossType);
db.SaveChanges();
status = 1;
}
catch (Exception ex)
{
ex.ToString();
}
}
return(Json(status, JsonRequestBehavior.AllowGet));
}
public bool Update(LossType ls)
{
string sql = string.Format("UPDATE LossType SET CatID='{0}', ", ls.CatId);
sql += string.Format("TypeName='{0}', ", ls.Name);
sql += string.Format("ReportTypeName='{0}', ", ls.ReportName);
sql += string.Format("SpanishTypeName='{0}', ", ls.SpanishName);
sql += string.Format("OverproductionFlag='{0}, ", ls.OverProductionFlag);
sql += string.Format("TrimWasteFlag='{0}, ", ls.TrimWasteFlag);
sql += string.Format("HandlingFlag='{0}, ", ls.HandlingFlag);
sql += string.Format("Rank='{0}, ", ls.Rank);
sql += string.Format("Enabled='{0}, ", ls.Enabled);
sql += string.Format("ModifiedDate='{0}, ", ls.ModifiedDate);
sql += string.Format("Description='{0} ", ls.Description);
sql += string.Format("WHERE TypeID='{0}'", ls.Id);
return(DB.Update(sql));
}
public void Compile(Optimizer optimizer, LossType loss, EvalMetric metric = null)
{
Metric = metric;
TrainMetric = metric;
Model = new Symbol(IntPtr.Zero);
Model = Symbol.Variable("X");
ModelOptimizer = optimizer;
foreach (var layer in Layers)
{
Model = layer.Build(Model);
foreach (var item in ((BaseLayer)layer).InitParams)
{
ParamInitializers.Add(item.Key, item.Value);
}
}
Model = LossRegistry.Get(loss, Model, Symbol.Variable("label"));
}
private LossType getDataObject(DataRow row)
{
LossType ls = new LossType();
ls.Id = row[0].ToString();
ls.Name = row[1].ToString();
ls.CatId = Convert.ToInt32(row[2].ToString());
ls.ReportName = row[3].ToString();
ls.SpanishName = row[4].ToString();
ls.OverProductionFlag = Boolean.Parse(row[5].ToString());
ls.TrimWasteFlag = Boolean.Parse(row[6].ToString());
ls.HandlingFlag = Boolean.Parse(row[7].ToString());
ls.Rank = Convert.ToInt32(row[8]);
ls.Enabled = Boolean.Parse(row[9].ToString());
ls.ModifiedDate = DateTime.Parse(row[10].ToString());
ls.Description = row[11].ToString();
return(ls);
}
private void LossCheck(PlayerController player)
{
LossType lossType = LossType.None;
if (player.City.GetInfectionImpactLossPercentage() >= 100)
{
lossType = LossType.Infection;
}
else if (player.City.PopulationManager.Population <= 0)
{
lossType = LossType.StarvedToDeath;
}
if (lossType != LossType.None)
{
RpcNotifyLoser(player.ConnectionID, (int)lossType);
player.LostAndDestroy();
}
}
public static Symbol Get(LossType lossType, Symbol preds, Symbol labels)
{
switch (lossType)
{
case LossType.MeanSquaredError:
return(MeanSquaredError(preds, labels));
case LossType.MeanAbsoluteError:
return(MeanAbsoluteError(preds, labels));
case LossType.MeanAbsolutePercentageError:
return(MeanAbsolutePercentageError(preds, labels));
case LossType.MeanAbsoluteLogError:
return(MeanAbsoluteLogError(preds, labels));
case LossType.SquaredHinge:
return(SquaredHinge(preds, labels));
case LossType.Hinge:
return(Hinge(preds, labels));
case LossType.SigmoidBinaryCrossEntropy:
return(SigmoidBinaryCrossEntropy(preds, labels));
case LossType.SoftmaxCategorialCrossEntropy:
return(SoftmaxCategorialCrossEntropy(preds, labels));
case LossType.CTC:
return(CTC(preds, labels));
case LossType.KullbackLeiblerDivergence:
return(KullbackLeiblerDivergence(preds, labels));
case LossType.Poisson:
return(Poisson(preds, labels));
default:
return(null);
}
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(LossType obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
public void Compile(BaseOptimizer optimizer, LossType loss, MetricType metric)
{
OptimizerFn = optimizer;
LossFn = BaseLoss.Get(loss);
MetricFn = BaseMetric.Get(metric);
}
public void Compile(OptimizerType optimizer, LossType loss, EvalMetric metric)
{
Optimizer opt = OptimizerRegistry.Get(optimizer);
Compile(opt, loss, metric);
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(LossType obj)
{
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
/// <summary>
/// Gets the specified loss type.
/// </summary>
/// <param name="lossType">Type of the loss.</param>
/// <returns></returns>
internal static BaseLoss Get(LossType lossType)
{
BaseLoss loss = null;
switch (lossType)
{
case LossType.MeanSquaredError:
loss = new MeanSquaredError();
break;
case LossType.MeanAbsoluteError:
loss = new MeanAbsoluteError();
break;
case LossType.MeanAbsolutePercentageError:
loss = new MeanAbsolutePercentageError();
break;
case LossType.MeanAbsoluteLogError:
loss = new MeanSquaredLogError();
break;
case LossType.SquaredHinge:
loss = new SquaredHinge();
break;
case LossType.Hinge:
loss = new Hinge();
break;
case LossType.BinaryCrossEntropy:
loss = new BinaryCrossentropy();
break;
case LossType.CategorialCrossEntropy:
loss = new CategoricalCrossentropy();
break;
case LossType.CTC:
break;
case LossType.KullbackLeiblerDivergence:
loss = new KullbackLeiblerDivergence();
break;
case LossType.Logcosh:
loss = new LogCosh();
break;
case LossType.Poisson:
loss = new Poisson();
break;
case LossType.CosineProximity:
loss = new CosineProximity();
break;
default:
break;
}
return(loss);
}
