private int CalculateLifelossScore(EvaluationParameters p)
{
var attackerParameters = GetAttackerParamers(p.Attacker, p.Blockers);
return(ScoreCalculator.CalculateLifelossScore(p.DefendersLife,
QuickCombat.CalculateDefendingPlayerLifeloss(attackerParameters)));
}
public IExpression Evaluate(EvaluationParameters parameters)
{
IExpression evalIndex = ParameterIndex.TryEvaluate(parameters);
int index = parameters.FunctionProvider.ToInteger(evalIndex);
return(new Expressions.GenericExpression(parameters[this.ParameterType, index]));
}
public IExpression Evaluate(EvaluationParameters parameters)
{
var evalCond = Condition.TryEvaluate(parameters);
if (parameters.FunctionProvider.ToBoolean(evalCond))
return TrueValue.TryEvaluate(parameters);
return FalseValue.TryEvaluate(parameters);
}
public IExpression Evaluate(EvaluationParameters parameters)
{
IExpression evalCond = Condition.TryEvaluate(parameters);
if (parameters.FunctionProvider.ToBoolean(evalCond))
{
return(TrueValue.TryEvaluate(parameters));
}
return(FalseValue.TryEvaluate(parameters));
}
public IExpression Evaluate(EvaluationParameters parameters)
{
var evalSwitch = CaseSwitch.TryEvaluate(parameters);
var asInt = parameters.FunctionProvider.ToInteger(evalSwitch);
INode caseNode;
if (!_Cases.TryGetValue(asInt, out caseNode))
throw new InvalidOperationException();
return caseNode.TryEvaluate(parameters);
}
public Othello_Minimax(State state, Random rnd, List <EvaluationParameters> eval_params = null)
{
this.my_state = state;
if (eval_params == null)
{
eval_params = EvaluationParameters.GenerateAllParams(rnd);
}
early = eval_params[0];
mid = eval_params[1];
late = eval_params[2];
}
public IExpression Evaluate(EvaluationParameters parameters)
{
var evalSwitch = CaseSwitch.TryEvaluate(parameters);
var asInt = parameters.FunctionProvider.ToInteger(evalSwitch);
INode caseNode;
if (!_Cases.TryGetValue(asInt, out caseNode))
{
throw new InvalidOperationException();
}
return(caseNode.TryEvaluate(parameters));
}
public static EvaluationParameters GenerateParams(int percent_threshold, Random rnd)
{
EvaluationParameters eval = new EvaluationParameters();
eval.enemy_corner_weight = GetParameterDouble(rnd);
eval.enemy_pieces_weight = GetParameterDouble(rnd);
eval.enemy_sideline_weight = GetParameterDouble(rnd);
eval.my_corner_weight = GetParameterDouble(rnd);
eval.my_pieces_weight = GetParameterDouble(rnd);
eval.my_piece_minus_enemy_piece_weight = GetParameterDouble(rnd);
eval.my_sideline_weight = GetParameterDouble(rnd);
eval.percent_threshold = percent_threshold;
eval.depth = rnd.Next(1, 5);
return(eval);
}
private int CalculateAttackerScore(EvaluationParameters p)
{
if (p.Attacker.Card.Has().Deathtouch)
{
return(0);
}
var attackerParamers = GetAttackerParamers(p.Attacker, p.Blockers);
if (QuickCombat.CanAttackerBeDealtLeathalDamage(attackerParamers) && !p.Attacker.Abilities.CanRegenerate)
{
return(p.Attacker.Card.Score);
}
return(0);
}
public async Task <PagedList <Evaluation> > GetEvaluationPagined(EvaluationParameters evaluationParameters)
{
var evaluations = FindAll();
if (String.IsNullOrWhiteSpace(evaluationParameters.BoutiqueName))
{
return(await PagedList <Evaluation> .ToPagedList(FindAll()
.Include(b => b.Boutique)
.Include(u => u.User)
.OrderBy(e => e.NoteGlobale), evaluationParameters.PageNumber, evaluationParameters.PageSize));
}
else
{
return(await PagedList <Evaluation> .ToPagedList(FindAll()
.Where(e => e.Boutique.Name.ToLower().Contains(evaluationParameters.BoutiqueName.Trim().ToLower()))
.Include(b => b.Boutique)
.Include(u => u.User)
.OrderBy(e => e.NoteGlobale), evaluationParameters.PageNumber, evaluationParameters.PageSize));
}
}
private int CalculateBlockersScore(EvaluationParameters p)
{
if (p.Blockers.Count == 0)
{
return(0);
}
var blockersRanks = p.Blockers.Select(blocker =>
{
var blockerParameters = GetBlockerParameters(p.Attacker, blocker);
var attackerParameters = GetAttackerParamers(p.Attacker, new[] { blocker });
return(new
{
Blocker = blocker,
CanBeKilled = QuickCombat.CanBlockerBeDealtLeathalCombatDamage(blockerParameters),
CanKill = QuickCombat.CanAttackerBeDealtLeathalDamage(attackerParameters)
});
})
.ToList();
if (blockersRanks.Any(x => !x.CanBeKilled))
{
return(0);
}
var leastValuedBlockerWhoCanKill = blockersRanks.Where(x => x.CanKill)
.OrderBy(x => x.Blocker.Card.Score)
.FirstOrDefault();
if (leastValuedBlockerWhoCanKill != null)
{
return(leastValuedBlockerWhoCanKill.Blocker.Card.Score);
}
return(blockersRanks.OrderBy(x => x.Blocker.Card.Score).First().Blocker.Card.Score);
}
public IExpression Evaluate(EvaluationParameters parameters)
{
return parameters.FunctionProvider.EvaluateGenericElement(parameters, this);
}
public IExpression Evaluate(EvaluationParameters parameters)
{
return(new Expressions.OpenTag(Tag, Arguments.Select(_ => _.TryEvaluate(parameters))));
}
public async Task <IActionResult> Index(string sortOrder, string currentFilter, EvaluationParameters evaluationParameter)
{
ViewBag.CurrentSort = sortOrder;
ViewBag.NameSortParam = sortOrder == "name_asc" ? "name_desc" : "name_asc";
ViewBag.DateSortParam = sortOrder == "date_desc" ? "" : "date_desc";
if (evaluationParameter.BoutiqueName != null)
{
evaluationParameter.PageSize = 1;
}
else
{
evaluationParameter.BoutiqueName = currentFilter;
}
ViewBag.CurrentFilter = evaluationParameter.BoutiqueName;
ViewBag.PageSize = evaluationParameter.PageSize;
ViewBag.PageNumber = evaluationParameter.PageNumber;
var listeEvaluation = await _repository.Evaluation.GetEvaluationPagined(evaluationParameter);
if (listeEvaluation == null)
{
_logger.LogError($"Erreur la liste des évaluations n'a pas pu être récupérée du serveur");
return(BadRequest("la liste des évaluations n'a pas pu être retournée"));
}
//error automapper null arg in constructor
//var listeEvalToReturn = _mapper.Map<PagedList<EvaluationListeDto>>(listeEvaluation);
return(View(listeEvaluation));
}
private int CalculateLifelossScore(EvaluationParameters p)
{
var attackerParameters = GetAttackerParamers(p.Attacker, p.Blockers);
return ScoreCalculator.CalculateLifelossScore(p.DefendersLife,
QuickCombat.CalculateDefendingPlayerLifeloss(attackerParameters));
}
private int CalculateBlockersScore(EvaluationParameters p)
{
if (p.Blockers.Count == 0)
return 0;
var blockersRanks = p.Blockers.Select(blocker =>
{
var blockerParameters = GetBlockerParameters(p.Attacker, blocker);
var attackerParameters = GetAttackerParamers(p.Attacker, new[] {blocker});
return new
{
Blocker = blocker,
CanBeKilled = QuickCombat.CanBlockerBeDealtLeathalCombatDamage(blockerParameters),
CanKill = QuickCombat.CanAttackerBeDealtLeathalDamage(attackerParameters)
};
})
.ToList();
if (blockersRanks.Any(x => !x.CanBeKilled))
return 0;
var leastValuedBlockerWhoCanKill = blockersRanks.Where(x => x.CanKill)
.OrderBy(x => x.Blocker.Card.Score)
.FirstOrDefault();
if (leastValuedBlockerWhoCanKill != null)
{
return leastValuedBlockerWhoCanKill.Blocker.Card.Score;
}
return blockersRanks.OrderBy(x => x.Blocker.Card.Score).First().Blocker.Card.Score;
}
private int CalculateScore(EvaluationParameters p)
{
return(CalculateBlockersScore(p)
+ CalculateLifelossScore(p)
- CalculateAttackerScore(p));
}
public IExpression Evaluate(EvaluationParameters parameters)
{
var evalIndex = ParameterIndex.TryEvaluate(parameters);
var index = parameters.FunctionProvider.ToInteger(evalIndex);
return new Expressions.GenericExpression(parameters[this.ParameterType, index]);
}
public IExpression Evaluate(EvaluationParameters parameters)
{
return(new Expressions.CloseTag(Tag));
}
public IExpression Evaluate(EvaluationParameters parameters)
{
return(parameters.FunctionProvider.EvaluateGenericElement(parameters, this));
}
public IExpression Evaluate(EvaluationParameters parameters) {
return new Expressions.OpenTag(Tag, Arguments.Select(_ => _.TryEvaluate(parameters)));
}
private int CalculateScore(EvaluationParameters p)
{
return CalculateBlockersScore(p)
+ CalculateLifelossScore(p)
- CalculateAttackerScore(p);
}
public static EvaluationResult EvaluateModel(string mlconfigPath, DataSetType dsType, EvaluationType evType, ProcessDevice pdevice)
{
var er = new EvaluationResult();
er.Header = new List <string>();
//device definition
DeviceDescriptor device = MLFactory.GetDevice(pdevice);
//Load ML model configuration file
var dicMParameters = MLFactory.LoadMLConfiguration(mlconfigPath);
//add full path of model folder since model file doesn't contains any absolute path
dicMParameters.Add("root", Project.GetMLConfigFolder(mlconfigPath));
// get model data paths
var dicPath = MLFactory.GetMLConfigComponentPaths(dicMParameters["paths"]);
var modelName = Project.GetParameterValue(dicMParameters["training"], "TrainedModel");
var nnModelPath = Path.Combine(dicMParameters["root"], modelName);
//check if model exists
if (!MLFactory.IsFileExist(nnModelPath))
{
return(er);
}
//check if dataset files exist
var dataPath = GetDataPath(dicMParameters, dsType);
if (!MLFactory.IsFileExist(dataPath))
{
//in case validation dataset is not defiend just export traininign dataset
if (dsType == DataSetType.Validation)
{
dataPath = GetDataPath(dicMParameters, DataSetType.Training);
}
if (!MLFactory.IsFileExist(dataPath))
{
return(er);
}
}
//get output classes in case the ml problem is classification
var strCls = dicMParameters.ContainsKey("metadata") ? dicMParameters["metadata"] : "";
er.OutputClasses = DataDescriptor.GetOutputClasses(strCls);
//Minibatch type
var mbTypestr = Project.GetParameterValue(dicMParameters["training"], "Type");
MinibatchType mbType = (MinibatchType)Enum.Parse(typeof(MinibatchType), mbTypestr, true);
var mbSizetr = Project.GetParameterValue(dicMParameters["training"], "BatchSize");
var mf = MLFactory.CreateMLFactory(dicMParameters);
//perform evaluation
var evParams = new EvaluationParameters()
{
MinibatchSize = uint.Parse(mbSizetr),
MBSource = new MinibatchSourceEx(mbType, mf.StreamConfigurations.ToArray(), dataPath, null, MinibatchSource.FullDataSweep, false),
Input = mf.InputVariables,
Ouptut = mf.OutputVariables,
};
//evaluate model
if (evType == EvaluationType.FeaturesOnly)
{
if (!dicMParameters.ContainsKey("metadata"))
{
throw new Exception("The result cannot be exported to Excel, since no metadata is stored in mlconfig file.");
}
var desc = ParseRawDataSet(dicMParameters["metadata"]);
er.Header = generateHeader(desc);
er.DataSet = FeatureAndLabels(nnModelPath, dataPath, evParams, device);
return(er);
}
else if (evType == EvaluationType.Results)
{
//define header
er.Header.Add(evParams.Ouptut.First().Name + "_actual");
er.Header.Add(evParams.Ouptut.First().Name + "_predicted");
var result = EvaluateFunction(nnModelPath, dataPath, evParams, device);
er.Actual = result.actual.ToList();
er.Predicted = result.predicted.ToList();
return(er);
}
else if (evType == EvaluationType.ResultyExtended)
{
//define header
er.Header.Add(evParams.Ouptut.First().Name + "_actual");
er.Header.Add(evParams.Ouptut.First().Name + "_predicted");
er.Actual = new List <float>();
er.Predicted = new List <float>();
er.ActualEx = new List <List <float> >();
er.PredictedEx = new List <List <float> >();
//
var resultEx = EvaluateFunctionEx(nnModelPath, dataPath, evParams, device);
for (int i = 0; i < resultEx.actual.Count(); i++)
{
var res1 = MLValue.GetResult(resultEx.actual[i]);
er.Actual.Add(res1);
var res2 = MLValue.GetResult(resultEx.predicted[i]);
er.Predicted.Add(res2);
}
er.ActualEx = resultEx.actual;
er.PredictedEx = resultEx.predicted;
return(er);
}
else
{
throw new Exception("Unknown evaluation type!");
}
}
public IExpression Evaluate(EvaluationParameters parameters) {
return new Expressions.GenericExpression(parameters.TopLevelParameters[Value]);
}
public static Dictionary <string, List <List <float> > > FeatureAndLabels(string nnModel, string dataPath, EvaluationParameters evParam, DeviceDescriptor device)
{
try
{
var fun = Function.Load(nnModel, device);
//
return(MLEvaluator.FeaturesAndLabels(fun, evParam, device));
}
catch (Exception)
{
throw;
}
}
private int CalculateAttackerScore(EvaluationParameters p)
{
if (p.Attacker.Card.Has().Deathtouch)
return 0;
var attackerParamers = GetAttackerParamers(p.Attacker, p.Blockers);
if (QuickCombat.CanAttackerBeDealtLeathalDamage(attackerParamers) && !p.Attacker.Abilities.CanRegenerate)
return p.Attacker.Card.Score;
return 0;
}
public IExpression Evaluate(EvaluationParameters parameters) {
return new Expressions.CloseTag(Tag);
}
public IExpression Evaluate(EvaluationParameters parameters)
{
return(new Expressions.GenericExpression(parameters.TopLevelParameters[Value]));
}
public static (List <List <float> > actual, List <List <float> > predicted) EvaluateFunctionEx(string nnModel, string dataPath, EvaluationParameters evParam, DeviceDescriptor device)
{
try
{
var fun = Function.Load(nnModel, device);
//
return(MLEvaluator.EvaluateFunctionEx(fun, evParam, device));
}
catch (Exception)
{
throw;
}
}
public IExpression Evaluate(EvaluationParameters parameters)
{
return(new Expressions.GenericExpression(parameters.FunctionProvider.Compare(parameters, ComparisonType, Left, Right)));
}
public IExpression Evaluate(EvaluationParameters parameters)
{
return new Expressions.GenericExpression(parameters.FunctionProvider.Compare(parameters, ComparisonType, Left, Right));
}
