public OutputConnector addOutput(int type)
{
OutputConnector dock = new OutputConnector(this, type);
node.Outputs.Children.Add(dock);
return(dock);
}
public Connection(OutputConnector output, InputConnector input)
{
Bezier = new BezierSegment()
{
IsStroked = true
};
// Set up the Path to insert the segments
PathGeometry pathGeometry = new PathGeometry();
PathFigure = new PathFigure();
PathFigure.IsClosed = false;
pathGeometry.Figures.Add(PathFigure);
this.InputConnector = input;
this.OutputConnector = output;
if (input == null || output == null)
{
Current = this;
}
PathFigure.Segments.Add(Bezier);
Path = new Path();
Path.IsHitTestVisible = false;
Path.Stroke = Graph.context.getPipeColor((input != null) ? input.type : output.type);
Path.StrokeThickness = 2;
Path.Data = pathGeometry;
Graph.canvas.Children.Add(Path);
((UIElement)Graph.canvas.Parent).MouseMove += Canvas_MouseMove;
}
public TensorflowReshape(ReadOnlySpan <int> dimensions, ReadOnlySpan <int> newShape)
{
Input = AddInput("input", dimensions);
_newShape = newShape.ToArray();
int toDetermIdx = -1;
int mul = 1;
for (int i = 0; i < newShape.Length; i++)
{
if (newShape[i] == -1)
{
toDetermIdx = i;
}
else
{
mul *= newShape[i];
}
}
if (toDetermIdx != -1)
{
_newShape[toDetermIdx] = dimensions.GetSize() / mul;
}
Output = AddOutput("output", _newShape);
}
/// <summary>
/// Delegate called when the mouse isup on the working canvas.
/// </summary>
/// <param name="pSender">The event sender.</param>
/// <param name="pEventArgs">The event arguments.</param>
private void OnWorkingCanvasMouseUp(object pSender, MouseButtonEventArgs pEventArgs)
{
// Release the mouse capture.
this.WorkingCanvas.ReleaseMouseCapture();
this.WorkingCanvas.MouseMove -= this.OnWorkingCanvasMouseMove;
this.WorkingCanvas.MouseUp -= this.OnWorkingCanvasMouseUp;
this.WorkingCanvas.Visibility = Visibility.Collapsed;
this.ConnectingLine.Visibility = Visibility.Collapsed;
// Trying to create the final connection.
if (this.mSourceConnector != null && this.mTargetConnector != null)
{
// Both defined means the connection can be created. Test have been made in the mouse move event handler.
AGraphViewModel lGraphViewModel = this.ParentView.DataContext as AGraphViewModel;
if (lGraphViewModel == null)
{
return;
}
PortViewModel lSourceViewModel = this.mSourceConnector.ParentPort.Content as PortViewModel;
PortViewModel lTargetViewModel = this.mTargetConnector.ParentPort.Content as PortViewModel;
// Requesting connection creation.
lGraphViewModel.RequestConnectionCreation(lSourceViewModel, lTargetViewModel);
}
// Forget the reference on connectors.
this.mSourceConnector = null;
this.mTargetConnector = null;
}
public int AddOutput(OutputConnector output)
{
var id = Outputs.Count;
Outputs.Add(output, id);
return(id);
}
public Mean(ReadOnlySpan <int> dimensions)
{
Input = AddInput("input", dimensions);
Output = AddOutput("output", new[] {
dimensions[0],
dimensions[1]
});
}
public K210RemovePadding(ReadOnlySpan <int> dimensions)
{
Input = AddInput("input", dimensions);
Output = AddOutput("output", new[] {
dimensions[0],
dimensions[1]
});
}
public GlobalAveragePool(ReadOnlySpan <int> dimensions)
{
Input = AddInput("input", dimensions);
Output = AddOutput("output", new[] {
dimensions[0],
dimensions[1],
1,
1
});
}
/// <summary>
/// Initializes a new instance of the <see cref="ConnectionCreationBehavior"/> class.
/// </summary>
/// <param name="pParent">The behavior parent view.</param>
/// <param name="pWorkingCanvas">The canvas containing the connection line to work with.</param>
public ConnectionCreationBehavior(SimpleGraphView pParent, Canvas pWorkingCanvas)
: base(pParent)
{
this.WorkingCanvas = pWorkingCanvas;
this.WorkingCanvas.Visibility = Visibility.Collapsed;
this.ConnectingLine.Visibility = Visibility.Collapsed;
this.mSourceConnector = null;
this.mTargetConnector = null;
}
protected void AddOutput <T>(string name, OutputConnector <T> outputConnector)
{
_outputs.Add(name, new ConnectorDescription
{
Name = name,
Delegate = outputConnector,
ConnectorType = ConnectorTypes.Output,
Type = outputConnector.Method.GetParameters().FirstOrDefault()?.ParameterType
});
}
public MatMul(ReadOnlySpan <int> aDim, ReadOnlySpan <int> bDim)
{
if (aDim.Length != bDim.Length)
{
throw new ArgumentException("Dimensions of A and B must be same.");
}
A = AddInputConnector <double>("A", aDim);
B = AddInputConnector <double>("B", bDim);
Y = AddOutputConnector("Y", new DenseTensor <double>(aDim).MatrixMultiply(new DenseTensor <double>(bDim)).Dimensions, OnEvaluateY);
}
public Transpose(ReadOnlySpan <int> dimensions, ReadOnlySpan <int> axes)
{
var newDims = new int[dimensions.Length];
for (int i = 0; i < axes.Length; i++)
{
newDims[i] = dimensions[axes[i]];
}
Input = AddInput("input", dimensions);
Output = AddOutput("output", newDims);
}
public Add(ReadOnlySpan <int> aDim, ReadOnlySpan <int> bDim, int broadcast, int?axis = default)
{
if (broadcast == 0 && !aDim.SequenceEqual(bDim))
{
throw new ArgumentException("Dimensions of A and B must be same.");
}
_broadcast = broadcast;
_axis = axis ?? aDim.Length - bDim.Length;
A = AddInputConnector <double>("A", aDim);
B = AddInputConnector <double>("B", bDim);
Y = AddOutputConnector("Y", aDim, OnEvaluateY);
}
private static void AllocateInputMemoryDefault(Layer layer, OutputConnector input, InferenceContext context)
{
switch (layer)
{
case K210Conv2d _:
context.GetOrAllocateKPUMemory(input);
break;
default:
context.GetOrAllocateMainMemory(input);
break;
}
}
public MidiMessageFilter(Guid nodeId) : base(nodeId)
{
_subject = new Subject <MidiMessage>();
var output = new OutputConnector <MidiMessage>(_subject.Where(Valid), Guid.Parse("{B7B1B419-1AEC-444F-8554-67415AB8F4F4}"));
_outputs.Add(output);
// StreamNote: PatteKi "und auch hier war ich :D" (2020-06-30 22:25)
// StreamNote: m4cx: "Da war ich auch dran ;)" (2020-06-30 22:26)
var input = new InputConnector <MidiMessage>(_subject, Guid.Parse("{482E6ABA-F11E-44CB-B945-D5DC6AE50286}"));
_inputs.Add(input);
}
public QuantizedExclusiveConcatenation(IEnumerable <ReadOnlyMemory <int> > dimensions)
{
int i = 0;
var inputs = new List <InputConnector>();
var outputDims = dimensions.First().ToArray();
outputDims[1] = 0;
foreach (var dimension in dimensions)
{
inputs.Add(AddInput("input" + i++, dimension.Span));
outputDims[1] += dimension.Span[1];
}
Inputs = inputs;
Output = AddOutput("output", outputDims);
}
public void AllocateInputMemory(QuantizedExclusiveConcatenation layer, OutputConnector input, InferenceContext context)
{
var totalAlloc = context.GetOrAllocateMainMemory(layer.Output);
uint offset = 0;
foreach (var node in layer.Inputs.Select(x => x.Connection.From))
{
if (context.MainMemoryMap.ContainsKey(node))
{
return;
}
uint size = (uint)node.Dimensions.GetSize();
context.MainMemoryMap.Add(node, new MemoryAllocation(totalAlloc.Node, offset, size));
offset += size;
}
}
/// <summary>
/// Starts the connection creation process from the given source connector.
/// </summary>
/// <param name="pSource">The source connector.</param>
public void StartCreation(OutputConnector pSource)
{
// Updating the source.
this.mSourceConnector = pSource;
// Making the working canvas visible and updating the line position.
this.ConnectingLine.From = this.mSourceConnector.Position;
this.ConnectingLine.To = this.mSourceConnector.Position;
this.WorkingCanvas.Visibility = Visibility.Visible;
this.ConnectingLine.Visibility = Visibility.Visible;
// Listening to the mouse move and up of the canvas to update the line.
this.WorkingCanvas.CaptureMouse();
this.WorkingCanvas.MouseMove -= this.OnWorkingCanvasMouseMove;
this.WorkingCanvas.MouseMove += this.OnWorkingCanvasMouseMove;
this.WorkingCanvas.MouseUp -= this.OnWorkingCanvasMouseUp;
this.WorkingCanvas.MouseUp += this.OnWorkingCanvasMouseUp;
}
public MemoryAllocation GetOrAllocateKPUMemory(OutputConnector output)
{
if (!KPUMemoryMap.TryGetValue(output, out var alloc))
{
var dimensions = output.Dimensions;
(var groups, var rowLength, _) = K210Helper.GetRowLayout(dimensions[3]);
var oneLineChannels = Math.Min(dimensions[1], groups);
var blocks = (int)Math.Ceiling(dimensions[1] / (double)oneLineChannels);
if (dimensions[1] == 921)
{
}
var size = rowLength * dimensions[2] * blocks;
alloc = new MemoryAllocation(KPUMemoryAllocator.Allocate((uint)size));
KPUMemoryMap.Add(output, alloc);
}
else
{
alloc.Node.AddRef();
}
return(alloc);
}
public MemoryAllocation GetOrAllocateMainMemory(OutputConnector output)
{
if (!MainMemoryMap.TryGetValue(output, out var alloc))
{
uint elementSize;
if (output.Owner.GetType().Name.StartsWith("Quantized"))
{
elementSize = 1;
}
else
{
switch (output.Owner)
{
case K210Conv2d _:
case K210AddPadding _:
case K210RemovePadding _:
case K210Upload _:
case layers.Quantize _:
case layers.Requantize _:
elementSize = 1;
break;
default:
elementSize = 4;
break;
}
}
var dimensions = output.Dimensions;
alloc = new MemoryAllocation(MainMemoryAllocator.Allocate((uint)dimensions.GetSize() * elementSize));
MainMemoryMap.Add(output, alloc);
}
else
{
alloc.Node.AddRef();
}
return(alloc);
}
public InputVariable(string name, ReadOnlySpan <int> dimensions)
: base(name)
{
Value = AddOutputConnector("Value", dimensions, OnEvaluateValue);
}
public L2Normalization(ReadOnlySpan <int> dimensions)
{
Input = AddInput("input", dimensions);
Output = AddOutput("output", dimensions);
}
internal Output(CodecApiElement parent, string propertyName)
: base(parent, propertyName)
{
_connectors = new OutputConnector(this, "Connectors");
}
public void AllocateInputMemory(Reshape layer, OutputConnector input, InferenceContext context)
{
context.MainMemoryMap.Add(layer.Output, context.GetOrAllocateMainMemory(layer.Input.Connection.From));
}
public Softmax(ReadOnlySpan <int> dimensions)
{
Input = AddInput("input", dimensions);
Output = AddOutput("output", dimensions);
}
public Add(ReadOnlySpan <int> aDimensions, ReadOnlySpan <int> bDimensions)
{
InputA = AddInput("inputA", aDimensions);
InputB = AddInput("inputB", bDimensions);
Output = AddOutput("output", aDimensions);
}
public Constant(Tensor <T> value)
{
_value = value;
Value = AddOutputConnector("Value", value.Dimensions, OnEvaluateValue);
}
public Logistic(ReadOnlySpan <int> dimensions)
{
Input = AddInput("input", dimensions);
Output = AddOutput("output", dimensions);
}
/// <summary>
/// Creates a connection from and output to an input of this block
/// </summary>
/// <typeparam name="T">The parameter type</typeparam>
/// <param name="name">The name of the input</param>
/// <param name="output">The output connector</param>
public void ConnectToInput <T>(string name, OutputConnector <T> output)
{
var connector = _inputs[name];
connector.Delegate = new InputConnector <T>(() => output());
}
public Softmax(ReadOnlySpan <int> inputDim, int axis = 1)
{
_axis = axis;
Input = AddInputConnector <double>("input", inputDim);
Output = AddOutputConnector("output", inputDim, OnEvaluateOutput);
}
