private static void CreateLayerInGraph(ComponentGraph graph, ComponentVertex vertex, RandomNumberGenerator <float> random) { if (graph.InDegree(vertex) == 0) { // use some arbitrary layout to start // source layer must be input layer that overrides it vertex.Layer = Layer.CreateFromArchitecture(new Shape(Shape.BWHC, -1, 100, 100, 100), vertex.Architecture, random); } else { IList <Shape> shapes = new List <Shape>(); foreach (Edge <ComponentVertex> edge in graph.InEdges(vertex)) { if (edge.Source.Layer == null) { NetworkGraphBuilder.CreateLayerInGraph(graph, edge.Source, random); } shapes.Add(edge.Source.Layer.OutputShape); } vertex.Layer = shapes.Count == 1 ? Layer.CreateFromArchitecture(shapes[0], vertex.Architecture, random) : Layer.CreateFromArchitecture(shapes, vertex.Architecture, random); } }
private static bool AddEdge(ComponentGraph graph, ComponentVertex sourceVertex, ComponentGraph targetGraph) { if (graph.AddEdges(targetGraph.Sources.Select(x => new Edge <ComponentVertex>(sourceVertex, x))) != targetGraph.Sinks.Count()) { return(false); } return(graph.AddEdges(targetGraph.Edges) == targetGraph.Size); }
private static ComponentGraph ParseArchitecture(string architecture, bool isNested) { // split architecture into elements that include layers, modules, and edges IList <string> components = ComponentGraph.SplitArchitecture(architecture, NetworkGraphBuilder.Delimiter); // extract elements that defines edges and modules (in A=... format) Dictionary <string, string> elements; Dictionary <string, ComponentGraph> modules; NetworkGraphBuilder.ParseComponents(components, out elements, out modules); // components must now contain edges only (in A-B-... format) ComponentGraph graph = ComponentGraph.FromComponents(components, elements, modules); // process nested graphs if (isNested) { // nested graphs must start with a single split layer IList <ComponentVertex> sources = graph.Sources.ToList(); if (sources.Count > 1) { ComponentVertex split = new ComponentVertex( Guid.NewGuid().ToString(), string.Format(CultureInfo.InvariantCulture, "SP{0}", sources.Count)); graph.AddEdges(sources.Select(x => new Edge <ComponentVertex>(split, x))); } // nested graphs must end with a single concat layer IList <ComponentVertex> sinks = graph.Sinks.ToList(); if (sinks.Count > 1) { ComponentVertex concat = new ComponentVertex(Guid.NewGuid().ToString(), "CONCAT"); graph.AddEdges(sinks.Select(x => new Edge <ComponentVertex>(x, concat))); } } return(graph); }
private static bool AddEdge(ComponentGraph graph, ComponentGraph sourceGraph, ComponentGraph targetGraph) { graph.AddEdges(sourceGraph.Sinks.Zip(targetGraph.Sources, (s, t) => new Edge <ComponentVertex>(s, t))); return(graph.AddEdges(targetGraph.Edges) == targetGraph.Size); }
private static bool AddEdge(ComponentGraph graph, ComponentGraph sourceGraph, ComponentVertex targetVertex) { return(graph.AddEdges(sourceGraph.Sinks.Select(x => new Edge <ComponentVertex>(x, targetVertex))) == sourceGraph.Sinks.Count()); }
private static bool AddEdge(ComponentGraph graph, ComponentVertex sourceVertex, ComponentVertex targetVertex) { return(graph.AddEdge(new Edge <ComponentVertex>(sourceVertex, targetVertex))); }
public static ComponentGraph FromComponents(IEnumerable <string> components, IDictionary <string, string> elements, IDictionary <string, ComponentGraph> modules) { ComponentGraph graph = new ComponentGraph(); Dictionary <string, ComponentVertex> vertices = new Dictionary <string, ComponentVertex>(); foreach (string component in components) { IList <string> parts = ComponentGraph.SplitArchitecture(component, NetworkGraphBuilder.Splitter); if (parts.Count >= 2 && parts.All(x => !string.IsNullOrEmpty(x))) { ComponentVertex sourceVertex = null; ComponentGraph sourceGraph = null; for (int i = 0, ii = parts.Count; i < ii; i++) { string key = parts[i]; ComponentGraph targetGraph = null; if (key.First() == NetworkGraphBuilder.StartQualifier && key.Last() == NetworkGraphBuilder.EndQualifier) { targetGraph = NetworkGraphBuilder.ParseArchitecture(key.Substring(1, key.Length - 2), true); } else { ComponentGraph moduleGraph; if (modules.TryGetValue(key, out moduleGraph)) { targetGraph = moduleGraph.Clone(true) as ComponentGraph; } } if (targetGraph != null) { if (i > 0) { bool result = sourceVertex != null?ComponentGraph.AddEdge(graph, sourceVertex, targetGraph) : ComponentGraph.AddEdge(graph, sourceGraph, targetGraph); if (!result) { throw new ArgumentException( string.Format(CultureInfo.InvariantCulture, Properties.Resources.E_InvalidNetArchitecture_DuplicateEdge, parts[i - 1], parts[i])); } } sourceVertex = null; sourceGraph = targetGraph; } else { ComponentVertex targetVertex; string arch; if (elements.TryGetValue(key, out arch)) { if (!vertices.TryGetValue(key, out targetVertex)) { vertices[key] = targetVertex = new ComponentVertex(key, arch); } } else { targetVertex = new ComponentVertex(Guid.NewGuid().ToString(), key); } if (i > 0) { bool result = sourceVertex != null?ComponentGraph.AddEdge(graph, sourceVertex, targetVertex) : ComponentGraph.AddEdge(graph, sourceGraph, targetVertex); if (!result) { throw new ArgumentException( string.Format(CultureInfo.InvariantCulture, Properties.Resources.E_InvalidNetArchitecture_DuplicateEdge, parts[i - 1], parts[i])); } } sourceVertex = targetVertex; sourceGraph = null; } } } else if (parts.Count == 1 && !string.IsNullOrEmpty(parts[0])) { graph.AddVertex(new ComponentVertex(Guid.NewGuid().ToString(), parts[0])); } else { throw new ArgumentException( string.Format(CultureInfo.InvariantCulture, Properties.Resources.E_InvalidNetArchitecture, component)); } } // recreate vertices keys, for the embedded graphs to have unique layers foreach (ComponentVertex vertex in graph.Vertices) { vertex.Key = Guid.NewGuid().ToString(); } return(graph); }
/// <summary> /// Initializes a new instance of the <see cref="ComponentGraph"/> class /// using existing graph as a source. /// </summary> /// <param name="other">The existing <see cref="ComponentGraph"/> to create this graph from.</param> /// <param name="cloneVertices">The value indicating whether the graph vertices should be cloned.</param> public ComponentGraph(ComponentGraph other, bool cloneVertices) : base(other, cloneVertices) { }
public static NetworkGraph CreateNetworkGraph(string architecture, bool addActivationLayers, bool addLossLayer) { if (architecture == null) { throw new ArgumentNullException(nameof(architecture)); } if (string.IsNullOrEmpty(architecture)) { throw new ArgumentException(Properties.Resources.E_InvalidNetArchitecture_NoLayers, nameof(architecture)); } // 1. parse architecture string and build preliminary graph ComponentGraph componentGraph = NetworkGraphBuilder.ParseArchitecture(architecture, false); // 2. create layers in the preliminary graph RandomNumberGenerator <float> random = null; //// new Random(0); foreach (ComponentVertex sink in componentGraph.Sinks) { NetworkGraphBuilder.CreateLayerInGraph(componentGraph, sink, random); } // 3. convert to network graph NetworkGraph graph = new NetworkGraph(); foreach (Edge <ComponentVertex> edge in componentGraph.Edges) { /*NetworkGraph sourceGraph = (edge.Source.Layer as RNNLayer)?.Graph; * NetworkGraph targetGraph = (edge.Target.Layer as RNNLayer)?.Graph; * * if (sourceGraph != null) * { * graph.AddGraph(sourceGraph); * if (targetGraph != null) * { * graph.AddEdges(sourceGraph.Sinks, targetGraph.Sources); * graph.AddGraph(targetGraph); * } * else * { * graph.AddEdges(sourceGraph.Sinks, edge.Target.Layer); * } * } * else if (targetGraph != null) * { * graph.AddEdges(edge.Source.Layer, targetGraph.Sources); * graph.AddGraph(targetGraph); * } * else*/ { graph.AddEdge(edge.Source.Layer, edge.Target.Layer); } } // 4. add missing loss layers if (addLossLayer) { NetworkGraphBuilder.AddLossLayers(graph); } // 5. add missing activation layers if (addActivationLayers) { NetworkGraphBuilder.AddActivationLayers(graph); } // 6. initialize stochastic biases with ReLU activations NetworkGraphBuilder.InitializeReLUs(graph); return(graph); }
public VisHost(Player.Player player) : base( GameWindowSettings.Default, //new GameWindowSettings { // IsMultiThreaded = false, // UpdateFrequency = 120 //}, new NativeWindowSettings { Size = new Vector2i(1600, 900), APIVersion = new Version(4, 5), Profile = ContextProfile.Compatability, Flags = ContextFlags.Default, Title = "NeuralBeat3", API = ContextAPI.OpenGL }) { Player = player; //TargetRenderFrequency = 144f; //this.RenderFrequency = 144.0; VSync = VSyncMode.On; UpdateFrame += VisHost_UpdateFrame; RenderFrame += VisHost_RenderFrame; Load += VisHost_Load; Unload += VisHost_Unload; Resize += VisHost_Resize; Closed += VisHost_Closed; Closing += VisHost_Closing; //Keyboard.KeyDown += Keyboard_KeyDown; //Keyboard.KeyUp += Keyboard_KeyUp; this.KeyDown += Keyboard_KeyDown; this.KeyUp += Keyboard_KeyUp; // set default shader loader ShaderProgram.DefaultLoader = new OpenTKExtensions.Loaders.MultiPathFileSystemLoader(SHADERPATH); // framedata setup frameData.GlobalTextures = globalTextures; // create components //components.Add(font = new Font(@"res\font\calibrib.ttf_sdf.2048.png", @"res\font\calibrib.ttf_sdf.2048.txt"), 1); components.Add(font = new Font(@"res\font\lucon.ttf_sdf.1024.png", @"res\font\lucon.ttf_sdf.1024.txt"), 1); components.Add(text = new TextManager("texmgr", font), 2); components.Add(keyboardActions = new KeyboardActionManager() { KeyboardPriority = int.MaxValue }, 1); components.Add(globalTextures); components.Add(frameCounter = new OpenTKExtensions.Components.FrameCounter(font)); components.Add(switcher = new ComponentSwitcher() { KeyForward = new KeySpec(Keys.Tab), KeyBackward = new KeySpec(Keys.Tab, KeyModifiers.Shift) }); switcher.Add(new Renderers.AnalysisDebugRenderer(font, Player)); switcher.Add(new Renderers.BasicShaderRenderer()); switcher.Add(new Renderers.ParticleRenderer()); var graph = new ComponentGraph(); graph.Add(new ParticleNode() { Name = "particles" }); graph.Add(new ScreenOutputNode() { Name = "output" });; graph.AddEdge(new NodePortReference() { Node = "particles", Port = "tex" }, new NodePortReference() { Node = "output", Port = "tex" }); switcher.Add(graph); //Thread.CurrentThread.Priority = ThreadPriority.AboveNormal; }