/// <summary>
/// Called when client wishes to eval some C# code
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public EvaluateResponse Post(EvaluateRequest request)
{
//validate request
new EvaluateRequestValidation()
.ValidateAndThrow(request);
EvaluateResponse response = null;
//carry out the strategy to evaluate code
new EvaluateRequestStrategy(
request,
evaluateResponse =>
{
response = evaluateResponse;
}).Execute();
//if the response isn't called,
//something is wrong.
if (response == null)
{
throw new InvalidOperationException(
"Response is null"
);
}
return(response);
}
public void Expand(IPatchworkServerClient client)
{
#if DEBUG
if (Children.Count != 0)
{
throw new Exception("Cannot expand an already expanded node");
}
if (IsGameEnd)
{
throw new Exception("Cannot expand a GameEnd node");
}
#endif
//Advance
{
var node = MonteCarloTreeSearchAlphaZero.NodePool.Value.Get();
State.CloneTo(node.State);
node.State.Fidelity = SimulationFidelity.NoPiecePlacing;
node.State.PerformAdvanceMove();
node.Parent = this;
node.PieceToPurchase = null;
node.NetworkChildIndex = 0;
Children.Add(node);
}
//Purchase
for (var i = 0; i < 3; i++)
{
//This cares if they can actually place the piece only when expanding the root node
if (Helpers.ActivePlayerCanPurchasePiece(State, Helpers.GetNextPiece(State, i)))
{
var node = MonteCarloTreeSearchAlphaZero.NodePool.Value.Get();
State.CloneTo(node.State);
node.State.Fidelity = SimulationFidelity.NoPiecePlacing;
var pieceIndex = node.State.NextPieceIndex + i;
node.State.PerformPurchasePiece(pieceIndex);
node.Parent = this;
node.PieceToPurchase = pieceIndex;
node.NetworkChildIndex = i + 1;
Children.Add(node);
}
}
//Evaluate the networks of our children
var req = new EvaluateRequest();
for (var i = 0; i < Children.Count; i++)
{
req.State.Add(GameStateFactory.CreateGameState(Children[i].State));
}
var res = client.Evaluate(req);
for (var i = 0; i < Children.Count; i++)
{
Children[i].NetworkResult = res.Evaluations[i];
}
}
public EvaluateRequestStrategy(
EvaluateRequest request,
Action <EvaluateResponse> responseHandler
)
{
this.Request = request;
this.ResponseHandler = responseHandler;
}
public static void CalcExpressionWithNotDeclared(Int64?frameId, string Expression)
{
EvaluateRequest evaluateRequest = new EvaluateRequest();
evaluateRequest.arguments.expression = Expression;
evaluateRequest.arguments.frameId = frameId;
var ret = VSCodeDebugger.Request(evaluateRequest);
Assert.False(ret.Success);
}
public void CheckErrorAtRequest(string caller_trace, Int64 frameId, string Expression)
{
EvaluateRequest evaluateRequest = new EvaluateRequest();
evaluateRequest.arguments.expression = Expression;
evaluateRequest.arguments.frameId = frameId;
var ret = VSCodeDebugger.Request(evaluateRequest);
Assert.False(ret.Success, @"__FILE__:__LINE__" + "\n" + caller_trace);
}
/// <summary>
/// Performs a MCTS search starting at the given state.
/// Returns the root of the search tree, you must call NodePool.Value.ReturnAll() afterwards.
/// </summary>
internal MCTSAZNode PerformMCTS(SimulationState state)
{
var root = NodePool.Value.Get();
state.CloneTo(root.State);
var req = new EvaluateRequest();
req.State.Add(GameStateFactory.CreateGameState(root.State));
var res = _client.Evaluate(req);
root.NetworkResult = res.Evaluations[0];
for (var i = 0; i < Iterations; i++)
{
//Selection
var leaf = Select(root);
float leafValue;
if (leaf.IsGameEnd)
{
//Value at a leaf is from the perspective of the player who performed an action to move the simulation to that state
leafValue = (leaf.State.WinningPlayer == leaf.Parent.State.ActivePlayer) ? 1 : -1;
}
else
{
//Expansion
Expand(leaf);
//Randomly choose one of the newly expanded nodes
leaf = Select(leaf);
//Simulation
leafValue = leaf.NetworkResult.WinRate;
}
//Backpropagation
do
{
leaf.ReceiveBackpropagation(leafValue);
leaf = leaf.Parent;
//Value at a leaf is from the perspective of the player who performed an action to move the simulation to that state
//When the player changes we need to negative the value so it is from the other players perspective
if (leaf != null && leaf.Parent != null && leaf.Parent.State.ActivePlayer != leaf.State.ActivePlayer)
{
leafValue = -leafValue;
}
} while (leaf != null);
}
return(root);
}
public void GetResultAsString(string caller_trace, Int64 frameId, string expr, out string strRes)
{
EvaluateRequest evaluateRequest = new EvaluateRequest();
evaluateRequest.arguments.expression = expr;
evaluateRequest.arguments.frameId = frameId;
var ret = VSCodeDebugger.Request(evaluateRequest);
Assert.True(ret.Success, @"__FILE__:__LINE__" + "\n" + caller_trace);
EvaluateResponse evaluateResponse = JsonConvert.DeserializeObject <EvaluateResponse>(ret.ResponseStr);
strRes = evaluateResponse.body.result;
}
public async Task <ActionResult <List <dynamic> > > PostClassifyAndEvalaute([FromBody] EvaluateRequest request)
{
if (string.IsNullOrWhiteSpace(request.ClassificationModelId))
{
return(BadRequest("classificationModelId cannot be null or empty"));
}
if (string.IsNullOrWhiteSpace(request.Url))
{
return(BadRequest("url cannot be null or empty"));
}
return(await _formRecognizerService.ScanRemote(request.ClassificationModelId, request.Url));
}
/// <summary>
/// 添加评价
/// </summary>
/// <param name="eva"></param>
/// <returns></returns>
public async Task <Order> AddevaluateAsync(EvaluateRequest eva)
{
try
{
var order = await _orderStore.GetAsync(a => a.Where(b => b.OrderId == eva.Orderid));
order.Evaluate = eva.Evaluate;
return(await _orderStore.UpdateOrder(order));
}
catch (Exception e)
{
throw e;
}
}
public void CalcAndCheckExpression(string caller_trace, Int64?frameId, string ExpectedResult, string Expression)
{
EvaluateRequest evaluateRequest = new EvaluateRequest();
evaluateRequest.arguments.expression = Expression;
evaluateRequest.arguments.frameId = frameId;
var ret = VSCodeDebugger.Request(evaluateRequest);
Assert.True(ret.Success, @"__FILE__:__LINE__" + "\n" + caller_trace);
EvaluateResponse evaluateResponse =
JsonConvert.DeserializeObject <EvaluateResponse>(ret.ResponseStr);
Assert.Equal(ExpectedResult, evaluateResponse.body.result, @"__FILE__:__LINE__" + "\n" + caller_trace);
}
public static string CalcExpression(Int64?frameId, string Expression)
{
EvaluateRequest evaluateRequest = new EvaluateRequest();
evaluateRequest.arguments.expression = Expression;
evaluateRequest.arguments.frameId = frameId;
var ret = VSCodeDebugger.Request(evaluateRequest);
Assert.True(ret.Success);
EvaluateResponse evaluateResponse =
JsonConvert.DeserializeObject <EvaluateResponse>(ret.ResponseStr);
return(evaluateResponse.body.result);
}
public void CheckErrorAtRequest(string caller_trace, Int64 frameId, string Expression, string errMsgStart)
{
EvaluateRequest evaluateRequest = new EvaluateRequest();
evaluateRequest.arguments.expression = Expression;
evaluateRequest.arguments.frameId = frameId;
var ret = VSCodeDebugger.Request(evaluateRequest);
Assert.False(ret.Success, @"__FILE__:__LINE__" + "\n" + caller_trace);
EvaluateResponse evaluateResponse =
JsonConvert.DeserializeObject <EvaluateResponse>(ret.ResponseStr);
Assert.True(evaluateResponse.message.StartsWith(errMsgStart), @"__FILE__:__LINE__" + "\n" + caller_trace);
}
internal bool IsEnum(string type, int frameId)
{
if (enumTypes.TryGetValue(type, out var isEnum))
{
return(isEnum);
}
var request = new EvaluateRequest($"typeof ({type}).IsEnum")
{
FrameId = frameId
};
var response = protocolClient.SendRequestSync(request);
isEnum = response.Result.Equals("true", StringComparison.OrdinalIgnoreCase);
enumTypes.Add(type, isEnum);
return(isEnum);
}
public async Task <IActionResult> Addevaluate(EvaluateRequest eva)
{
string userName = HttpContext.Session.GetString("UserName");
log.InfoFormat(userName + " || Get into 添加评价");
try
{
var list = await _orderManager.AddevaluateAsync(eva);
log.InfoFormat("添加评价成功" + (list != null ? Helper.JsonHelper.ToJson(list) : ""));
ViewData["UserName"] = userName;
return(RedirectToAction("Orderbuylist"));
}
catch (Exception e)
{
log.Error("添加评价失败,错误提示: " + Helper.JsonHelper.ToJson(e));
return(View("Error", e));
}
}
public IEnumerator Evaluate(LayerType[] simpleLayers)
{
EvaluateRequest req = new EvaluateRequest {
};
bool flat = false;
for (int i = 0; i < simpleLayers.Length; i++)
{
LayerType l = simpleLayers[i];
switch (l)
{
case LayerType.Conv:
if (flat)
{
throw new System.ArgumentException("tried to add multidimensional layer after flatten");
}
req.Layers.Add(new Evaluator.Layer {
Convolution = new Evaluator.ConvolutionLayer {
Filters = 32
}
});
break;
case LayerType.Full:
case LayerType.Dense:
if (!flat)
{
req.Layers.Add(new Evaluator.Layer {
Flatten = new Evaluator.FlattenLayer {
}
});
flat = true;
}
req.Layers.Add(new Evaluator.Layer {
Dense = new Evaluator.DenseLayer {
Neurons = 128
}
});
break;
case LayerType.Pool:
if (flat)
{
throw new System.ArgumentException("tried to add multidimensional layer after flatten");
}
req.Layers.Add(new Evaluator.Layer {
Maxpooling = new Evaluator.MaxpoolingLayer {
}
});
break;
case LayerType.Dropout:
req.Layers.Add(new Evaluator.Layer {
Dropout = new Evaluator.DropoutLayer {
Dimension = 0.5f
}
});
break;
default:
throw new System.ArgumentException("unknown layer type: " + l);
}
}
if (!flat)
{
req.Layers.Add(new Evaluator.Layer {
Flatten = new Evaluator.FlattenLayer {
}
});
}
using (var call = client.EvaluateAsync(req)) {
while (!call.ResponseAsync.IsCompleted)
{
yield return(new WaitForSeconds(0.5f));
}
accuracy = call.ResponseAsync.Result.Accuracy;
if (manager)
{
manager.SetAcurracyText(accuracy);
}
}
}
public IEnumerator Evaluate(CLayerType[] simpleLayers)
{
if (modelHandler)
{
modelHandler.ShowGPUs(true);
}
EvaluateRequest req = new EvaluateRequest {
};
bool flat = false;
for (int i = 0; i < simpleLayers.Length; i++)
{
CLayerType l = simpleLayers[i];
switch (l)
{
case CLayerType.Conv:
if (flat)
{
throw new System.ArgumentException("tried to add multidimensional layer after flatten");
}
req.Layers.Add(new Evaluator.Layer {
Convolution = new Evaluator.ConvolutionLayer {
Filters = 32
}
});
break;
case CLayerType.Full:
case CLayerType.Dense:
if (!flat)
{
req.Layers.Add(new Evaluator.Layer {
Flatten = new Evaluator.FlattenLayer {
}
});
flat = true;
}
req.Layers.Add(new Evaluator.Layer {
Dense = new Evaluator.DenseLayer {
Neurons = 128
}
});
break;
case CLayerType.Pool:
if (flat)
{
throw new System.ArgumentException("tried to add multidimensional layer after flatten");
}
req.Layers.Add(new Evaluator.Layer {
Maxpooling = new Evaluator.MaxpoolingLayer {
}
});
break;
case CLayerType.Dropout:
req.Layers.Add(new Evaluator.Layer {
Dropout = new Evaluator.DropoutLayer {
Dimension = 0.5f
}
});
break;
default:
throw new System.ArgumentException("unknown layer type: " + l);
}
}
if (!flat)
{
//req.Layers.Add(new Evaluator.Layer { Convolution = new Evaluator.ConvolutionLayer { Filters = 32 } });
req.Layers.Add(new Evaluator.Layer {
Flatten = new Evaluator.FlattenLayer {
}
});
}
bIsCalculating = true;
using (var call = client.EvaluateAsync(req)) {
//StartCoroutine(UpdateProgress());
while (!call.ResponseAsync.IsCompleted)
{
//accuracy = call.ResponseAsync.Result.Accuracy;
yield return(new WaitForSeconds(0.5f));
}
bIsCalculating = false;
accuracy = call.ResponseAsync.Result.Accuracy;
if (manager)
{
manager.CompleteComputation(accuracy);
}
yield return(new WaitForSeconds(0.5f));
if (modelHandler)
{
modelHandler.Reset();
}
}
}
// Note: displayType will often have spaces after commas
string GetFixedValue(string value, string canonType, string displayType)
{
int arrayIndex;
if (IsMultiDimensionalArray(displayType, out arrayIndex))
{
var arrayType = displayType.Substring(0, arrayIndex);
var prefix = $"{{{arrayType}[";
if (value.StartsWith(prefix, StringComparison.Ordinal))
{
var compacted = new StringBuilder(prefix.Replace(", ", ","));
int index = prefix.Length;
while (index < value.Length)
{
int endIndex = value.IndexOfAny(CommaDotOrSquareEndBracket, index);
string number;
if (endIndex == -1)
{
return(value);
}
if (endIndex + 1 < value.Length && value[endIndex] == '.' && value[endIndex + 1] == '.')
{
int min, max;
number = value.Substring(index, endIndex - index);
if (!int.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out min))
{
return(value);
}
index = endIndex + 2;
if ((endIndex = value.IndexOfAny(CommaOrSquareEndBracket, index)) == -1)
{
return(value);
}
number = value.Substring(index, endIndex - index);
if (!int.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out max))
{
return(value);
}
compacted.Append(((max - min) + 1).ToString(CultureInfo.InvariantCulture));
}
else
{
compacted.Append(value, index, endIndex - index);
}
compacted.Append(value[endIndex]);
index = endIndex + 1;
if (value[endIndex] == ']')
{
break;
}
if (index < value.Length && value[index] == ' ')
{
index++;
}
}
compacted.Append('}');
return(compacted.ToString());
}
}
else if (canonType == "char")
{
int startIndex = value.IndexOf('\'');
if (startIndex != -1)
{
return(value.Substring(startIndex));
}
}
else
{
var request = new EvaluateRequest($"typeof ({displayType}).IsEnum")
{
FrameId = frameId
};
var result = vsCodeDebuggerSession.protocolClient.SendRequestSync(request);
if (result.Result.Equals("true", StringComparison.OrdinalIgnoreCase))
{
int endIndex = value.IndexOf(" | ", StringComparison.Ordinal);
if (endIndex != -1)
{
// The value a bitwise-or'd set of enum values
var expanded = new StringBuilder();
int index = 0;
while (index < value.Length)
{
endIndex = value.IndexOf(" | ", index, StringComparison.Ordinal);
string enumValue;
if (endIndex != -1)
{
enumValue = value.Substring(index, endIndex - index);
}
else if (index > 0)
{
enumValue = value.Substring(index);
}
else
{
enumValue = value;
}
expanded.Append(canonType).Append('.').Append(enumValue);
if (endIndex == -1)
{
break;
}
expanded.Append(" | ");
index = endIndex + 3;
}
return(expanded.ToString());
}
return(canonType + "." + value);
}
}
return(value);
}
public IActionResult Evaluate([FromBody] EvaluateRequest request)
{
try
{
var jtoken = request.Process;
var json = jtoken.ToString();
var rootAst = JsonParser.ParseMRule(json);
var process = RuleToCSharpCompiler.CreateFromAst(
rootAst,
new string[] { "ce_toy_fx.sample.web.Models", "ce_toy_fx.sample.web.Models.VariableTypes" },
new Type[] { typeof(Variables) });
var applicants = request.Application.Applicants.Select(x => x.ToInternalModel()).ToList();
/*
* var applicants = new List<Applicant>
* {
* new Applicant
* {
* Id = "a1",
* KeyValueMap = new Dictionary<string,object>
* {
* { Variables.Age, 25 },
* { Variables.Credit, 1000 },
* { Variables.CreditA, 250 },
* { Variables.CreditB, 250 },
* { Variables.Salary, 100 },
* { Variables.Flags, 1 },
* { Variables.Deceased, false },
* { Variables.Address, new Address { Street = "Street 1", PostalCode = "12345" } },
* { Variables.Role, Roles.Primary },
* }.ToImmutableDictionary()
* },
* new Applicant
* {
* Id = "a2",
* KeyValueMap = new Dictionary<string,object>
* {
* { Variables.Age, 35 },
* { Variables.Credit, 100 },
* { Variables.CreditA, 25 },
* { Variables.CreditB, 0 },
* { Variables.Salary, 200 },
* { Variables.Flags, 0 },
* { Variables.Deceased, false },
* { Variables.Address, new Address { Street = "Street 2", PostalCode = "58098" } },
* { Variables.Role, Roles.Other },
* }.ToImmutableDictionary()
* }
* };
*/
var evalResult = process.RuleExpr(new RuleExprContext <Unit>
{
Log = ImmutableList <LogEntry> .Empty,
Amount = request.Application.RequestedAmount,
Applicants = applicants.ToDictionary(x => x.Id).ToImmutableDictionary()
});
return(Json(evalResult.Item1.isSome ? ("Granted, " + evalResult.Item2.Amount) : "Rejected"));
}
catch (Exception e)
{
return(Json(e.Message));
}
}
public EvaluateReply Evaluate(EvaluateRequest request)
{
return(Evaluate(request, null));
}
public IHttpActionResult Match(EvaluateRequest request)
{
return(Ok());
}
