public void TestEcnounters()
{
var graph = new Graph();
var v1 = graph.AddVertex(new Vertex("v1", 0));
var v2 = graph.AddVertex(new Vertex("v2", 0));
var v3 = graph.AddVertex(new Vertex("v3", 0));
var v4 = graph.AddVertex(new Vertex("v4", 0));
var v1v2 = graph.AddEdge("v1", "v2");
var v2v4 = graph.AddEdge("v2", "v4");
var v1v3 = graph.AddEdge("v1", "v3");
var v3v4 = graph.AddEdge("v3", "v4");
var cGraph = new ComputationGraph(graph, new DfsPathFinder(), v1, v4);
Assert.AreEqual(2, cGraph.Elements[v1].EncountsCount);
Assert.AreEqual(1, cGraph.Elements[v2].EncountsCount);
Assert.AreEqual(1, cGraph.Elements[v3].EncountsCount);
Assert.AreEqual(2, cGraph.Elements[v4].EncountsCount);
Assert.AreEqual(1, cGraph.Elements[v1v2].EncountsCount);
Assert.AreEqual(1, cGraph.Elements[v2v4].EncountsCount);
Assert.AreEqual(1, cGraph.Elements[v1v3].EncountsCount);
Assert.AreEqual(1, cGraph.Elements[v3v4].EncountsCount);
}
public Guid StartSession(ComputationGraph graph)
{
Guid sessionId = Guid.NewGuid();
lock (_lockGuard)
{
_sessionGraphs.Add(sessionId, graph);
_logger.LogInformation($"Create session with id: {sessionId}");
var session = new SessionStatus
{
OperationStatus = graph.Operations
.Select(op => new OperationStatus {
Id = op.Id, State = OperationState.Awaits
})
.ToList(),
MnemonicsTable = graph.MnemonicsTable
};
_sessions.Add(sessionId, session);
LogSessionStatus(sessionId);
List <int> availableOperations =
session.GetAvailableOperationsIds(_sessionGraphs[sessionId].Dependencies);
EnqueueOperationsExecution(sessionId, availableOperations);
return(sessionId);
}
}
public ComputationGraphNetwork([NotNull] ComputationGraph graph) : base(NetworkType.ComputationGraph)
{
Graph = graph;
OutputLayer = Graph.OutputNode.To <IComputationGraphNode, ProcessingNode>().Layer.To <INetworkLayer, OutputLayerBase>();
Layers = Graph.ProcessingNodes.Select(node => node.Layer).ToArray();
WeightedLayersIndexes = Layers.Select((l, i) => (Layer: l as WeightedLayerBase, Index: i)).Where(t => t.Layer != null).Select(t => t.Index).ToArray();
}
public void Notify(Guid idSession, int idOperation, string[] outputs)
{
lock (lockUpdateStatus)
{
OperationStatus operationSt = sessionStatus[idSession].operationStatus[idOperation];
if (outputs != null)
{
SessionUtilities.OperationCompleted(operationSt, outputs);
ComputationGraph session = sessionDictionary[idSession];
SessionUtilities.UpdateMnemonicValues(sessionStatus[idSession].mnemonicsTable,
session.Operations[idOperation].Output,
outputs);
GetLogSession(idSession);
if (!SessionUtilities.SessionCompleted(sessionStatus[idSession].operationStatus))
{
List <int> idAvailableOperation = SessionUtilities.GetIDAvailableOperation(
sessionStatus[idSession].operationStatus,
sessionDictionary[idSession].Dependecies);
OperationsToExecute(idSession, idAvailableOperation);
}
else
{
StopSession(idSession);
}
}
else
{
SessionUtilities.OperationFaild(operationSt);
StopSession(idSession);
}
}
}
public Guid StartSession(ComputationGraph session)
{
Guid idSession = Guid.NewGuid();
lock (lockListSession)
{
sessionDictionary.Add(idSession, session);
}
_logger.LogInformation($"Create session with id: {idSession}");
List <OperationStatus> opStatus = new List <OperationStatus>();
foreach (Operation operation in session.Operations)
{
opStatus.Add(new OperationStatus(operation.Id, StatusEnum.Awaits));
}
lock (lockUpdateStatus)
{
sessionStatus.Add(idSession, new SessionStatus(opStatus, session.MnemonicsValues));
}
GetLogSession(idSession);
lock (lockListSession)
{
List <int> idAvailableOperation = SessionUtilities.GetIDAvailableOperation(
sessionStatus[idSession].operationStatus,
sessionDictionary[idSession].Dependecies);
OperationsToExecute(idSession, idAvailableOperation);
}
return(idSession);
}
public void StopSession(Guid id)
{
ComputationGraph session = sessionDictionary[id];
SessionStatus status = sessionStatus[id];
if (SessionUtilities.SessionCompleted(status.operationStatus))
{
Console.WriteLine("Session COMPLITED");
return;
//сессия закончена - всё ОК
}
else
if (SessionUtilities.SessionFaild(status.operationStatus))
{
foreach (OperationStatus operation in status.operationStatus.Where(op => op.status == StatusEnum.Awaits))
{
operation.status = StatusEnum.Aborted;
}
Console.WriteLine("Session FAILD");
//одна операция сломалась значит другие отменяем
//в целом сессия Faild
}
else
{
foreach (OperationStatus operation in status.operationStatus.Where(op => op.status == StatusEnum.Awaits))
{
operation.status = StatusEnum.Aborted;
}
Console.WriteLine("Session Aborted");
//сессия была отменена пользователем
//в целом сессия Aborted
}
}
public IActionResult Post([FromBody] ComputationGraph graph)
{
var s = _manager.StartSession(graph);
//validation
return(Ok(s));
}
public void Creates_computation_chain()
{
var codeAsText = File.ReadAllText(@"SyntaxAnalyserExamples/TestFunctions.cs");
var syntaxTree = SyntaxOperations.Parse(codeAsText);
var semanticModel = SemanticOperations.GetSemanticModel(syntaxTree);
var methodSyntax = SyntaxOperations
.FindMethodsOfClass(syntaxTree, nameof(TestFunctions), nameof(TestFunctions.ProcessInt32Parameter))
.Value
.Single();
var methodAnalysis = MethodBlockAnalysis.FromSemanticModel(methodSyntax, semanticModel);
var returnSyntax = methodAnalysis.BodyBlock.DescendantNodes().OfType <ReturnStatementSyntax>().Single();
var identSyntax = SyntaxOperations.GetVariable(returnSyntax);
var chainHead = ComputationGraph.FromReturnStatement(returnSyntax, methodAnalysis, methodAnalysis.MethodDeclarationSyntax.Span).Item1.A;
var sqrtDoubledIncrementedInt = _Assert_ReturnStatement(chainHead).A;
var localDecl_sqrtDoubledIncrementedInt = _Assert_Identifier(sqrtDoubledIncrementedInt, "sqrtDoubledIncrementedInt").A;
var castToInt = _Assert_LocalDeclaration(localDecl_sqrtDoubledIncrementedInt, "sqrtDoubledIncrementedInt").A;
var sqrtDoubledIncremented = _Assert_CastExpression(castToInt, typeof(int), methodAnalysis).A;
var localDecl_sqrtDoubledIncremented = _Assert_Identifier(sqrtDoubledIncremented, "sqrtDoubledIncremented").A;
var sqrt = _Assert_LocalDeclaration(localDecl_sqrtDoubledIncremented, "sqrtDoubledIncremented").A;
var(mathClassSqrt, args_doubledIncremented) = _Assert_Invocation(sqrt, nameof(Math.Sqrt));
var localDecl_doubledIncremented = _Assert_Identifier(args_doubledIncremented.Single().A, "doubledIncremented").A;
var parenthesizedExprAdd = _Assert_LocalDeclaration(localDecl_doubledIncremented, "doubledIncremented").A;
var binary_add = _Assert_ParenthesizedExpr(parenthesizedExprAdd).A;
var(doubled, oneLiteral) = _Assert_BinaryExpression(binary_add, operatorToken: SyntaxKind.PlusToken);
_Assert_Literal(oneLiteral.A, 1);
var localDecl_doubled = _Assert_Identifier(doubled.A, "doubled").A;
var parenthesizedExprMult = _Assert_LocalDeclaration(localDecl_doubled, "doubled").A;
var binary_mult = _Assert_ParenthesizedExpr(parenthesizedExprMult).A;
var(twoLiteral, x) = _Assert_BinaryExpression(binary_mult, operatorToken: SyntaxKind.AsteriskToken);
_Assert_Literal(twoLiteral.A, 2);
var methodParam = _Assert_Identifier(x.A, "x").A;
_Assert_MethodParam(methodParam, "x", typeof(int), methodAnalysis);
}
public static INeuralNetwork NewGraph(TensorInfo input, [NotNull] Action <NodeBuilder> builder)
{
NodeBuilder root = NodeBuilder.Input();
builder(root);
ComputationGraph graph = ComputationGraph.New(input, root);
return(new ComputationGraphNetwork(graph));
}
public void Creates_computation_chain_ramifying_code()
{
var codeAsText = File.ReadAllText(@"SyntaxAnalyserExamples/TestFunctions.cs");
var syntaxTree = SyntaxOperations.Parse(codeAsText);
var semanticModel = SemanticOperations.GetSemanticModel(syntaxTree);
var methodSyntax = SyntaxOperations
.FindMethodsOfClass(syntaxTree, nameof(TestFunctions), nameof(TestFunctions.ProcessInt32arameterWithRamification))
.Value
.Single();
var methodAnalysis = MethodBlockAnalysis.FromSemanticModel(methodSyntax, semanticModel);
var returnSyntax = methodAnalysis.BodyBlock.DescendantNodes().OfType <ReturnStatementSyntax>().Single();
var chainHead = ComputationGraph.FromReturnStatement(returnSyntax, methodAnalysis, methodAnalysis.MethodDeclarationSyntax.Span).Item1.A;
}
public void Creates_computation_chain_from_member_access_expr()
{
var codeAsText = File.ReadAllText(@"SyntaxAnalyserExamples/TestFunctions.cs");
var syntaxTree = SyntaxOperations.Parse(codeAsText);
var semanticModel = SemanticOperations.GetSemanticModel(syntaxTree);
var methodSyntax = SyntaxOperations
.FindMethodsOfClass(syntaxTree, nameof(TestFunctions), nameof(TestFunctions.ProcessStringParameter))
.Value
.Single();
var methodAnalysis = MethodBlockAnalysis.FromSemanticModel(methodSyntax, semanticModel);
var returnSyntax = methodAnalysis.BodyBlock.DescendantNodes().OfType <ReturnStatementSyntax>().Single();
var chainHead = ComputationGraph.FromReturnStatement(returnSyntax, methodAnalysis, methodAnalysis.MethodDeclarationSyntax.Span).Item1.A;
var propAccess_Name = _Assert_ReturnStatement(chainHead);
var invoc_GetType = _Assert_MemberAccess(propAccess_Name, nameof(Type.Name)).A;
var(memberAccess_GetType, args) = _Assert_Invocation(invoc_GetType, nameof(object.GetType));
CollectionAssert.That.IsEmpty(args);
var invoc_ElementAt = _Assert_MemberAccess(memberAccess_GetType, nameof(object.GetType)).A;
var(memberAccess_ElementAt, elementAt_Args) = _Assert_Invocation(invoc_ElementAt, "ElementAt");
_Assert_Literal(elementAt_Args.Single().A, 2);
var ident_x = _Assert_MemberAccess(memberAccess_ElementAt, "ElementAt").A;
var methodParam_x = _Assert_Identifier(ident_x, "x").A;
_Assert_MethodParam(methodParam_x, "x", typeof(string), methodAnalysis);
}
