1112 lines
32 KiB
C#
1112 lines
32 KiB
C#
using System.Collections.Generic;
|
|
using System.Linq;
|
|
|
|
namespace Unity.Barracuda {
|
|
|
|
/// <summary>
|
|
/// Verbose proxy to other `IOps` implementation
|
|
/// </summary>
|
|
public class VerboseOps : IOps, IModelCompiler
|
|
{
|
|
private bool m_UseUnityLogFile;
|
|
private IOps m_Ops;
|
|
private const string Prefix = "After ";
|
|
|
|
/// <summary>
|
|
/// Create `VerboseOps` for target `ops`
|
|
/// </summary>
|
|
/// <param name="ops">target `IOps` instance</param>
|
|
/// <param name="ops">produce log in Unity standard log file, model execution reporter from IOps will always be used if it exist.</param>
|
|
public VerboseOps(IOps ops, bool useUnityLogFile = true)
|
|
{
|
|
m_Ops = ops;
|
|
m_UseUnityLogFile = useUnityLogFile;
|
|
}
|
|
|
|
#if ENABLE_BARRACUDA_STATS
|
|
/// <inheritdoc/>
|
|
public IEnumerable<TempMemoryStatistics> GetTempMemoryStatistics()
|
|
{
|
|
return m_Ops.GetTempMemoryStatistics();
|
|
}
|
|
#endif //ENABLE_BARRACUDA_STATS
|
|
|
|
/// <inheritdoc/>
|
|
public virtual void PrepareModel(Model model, IDictionary<string, TensorShape> inputShapes, IVars vars)
|
|
{
|
|
if (m_Ops is IModelCompiler)
|
|
((IModelCompiler)m_Ops).PrepareModel(model, inputShapes, vars);
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public virtual void PostLayerCleanup()
|
|
{
|
|
m_Ops.PostLayerCleanup();
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public virtual void PreExecuteLayer(Layer layer, Tensor[] inputs)
|
|
{
|
|
if (m_Ops is IModelCompiler)
|
|
((IModelCompiler)m_Ops).PreExecuteLayer(layer, inputs);
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.MatMul(Tensor X, int rankX, Tensor Y, int rankY)
|
|
{
|
|
LogLayerSummary(rankX + ":(" + X.batch * X.channels + "," + X.height + "," + X.width + ")" +
|
|
" *" + rankY + ":(" + Y.batch * Y.channels + "," + Y.height + "," + Y.width + ")");
|
|
var O = m_Ops.MatMul(X, rankX, Y, rankY);
|
|
LogOutputTensorSummary(O, Prefix + "MatMul");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.MatMul(Tensor X, bool xTranspose, Tensor Y, bool yTranspose)
|
|
{
|
|
|
|
LogLayerSummary("(" + X.flatHeight + "," + X.flatWidth + ")" + (xTranspose ? ".T" : "") +
|
|
" * (" + Y.flatHeight + "," + Y.flatWidth + ")" + (yTranspose ? ".T" : ""));
|
|
var O = m_Ops.MatMul(X, xTranspose, Y, yTranspose);
|
|
LogOutputTensorSummary(O, Prefix + "MatMul");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Dense(Tensor X, Tensor W, Tensor B, Layer.FusedActivation fusedActivation)
|
|
{
|
|
LogLayerSummary(X.shape + " * (" + W.flatHeight + "," + W.flatWidth + ") + (" + B.flatWidth + ")");
|
|
var O = m_Ops.Dense(X, W, B, fusedActivation);
|
|
LogOutputTensorSummary(O, Prefix + "Dense");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Dense3(Tensor X, Tensor W, Tensor B)
|
|
{
|
|
LogLayerSummary(X.shape + " * (" + W.flatHeight + "," + W.flatWidth + ") + (" + B.flatWidth + ")");
|
|
var O = m_Ops.Dense3(X, W, B);
|
|
LogOutputTensorSummary(O, Prefix + "Dense3");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Conv2D(Tensor X, Tensor K, Tensor B, int[] stride, int[] pad, Layer.FusedActivation fusedActivation)
|
|
{
|
|
LogLayerSummary(X.shape + " # " + K.shape + " + (" + B.flatWidth + ")");
|
|
var O = m_Ops.Conv2D(X, K, B, stride, pad, fusedActivation);
|
|
LogOutputTensorSummary(O, Prefix + "Conv2D");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Conv3D(Tensor X, Tensor K, Tensor B, int[] stride, int[] pad, Layer.FusedActivation fusedActivation)
|
|
{
|
|
LogLayerSummary(X.shape + " # " + K.shape + " + (" + B.flatWidth + ")");
|
|
var O = m_Ops.Conv3D(X, K, B, stride, pad, fusedActivation);
|
|
LogOutputTensorSummary(O, Prefix + "Conv3D");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.DepthwiseConv2D(Tensor X, Tensor K, Tensor B, int[] stride, int[] pad, Layer.FusedActivation fusedActivation)
|
|
{
|
|
LogLayerSummary(X.shape + " ∆ " + K.shape + " + (" + B.flatWidth + ")");
|
|
var O = m_Ops.DepthwiseConv2D(X, K, B, stride, pad, fusedActivation);
|
|
LogOutputTensorSummary(O, Prefix + "DepthwiseConv2D");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Conv2DTrans(Tensor X, Tensor K, Tensor B, int[] stride, int[] pad, int[] outputAdjustment, Layer.FusedActivation fusedActivation)
|
|
{
|
|
LogLayerSummary(X.shape + " @ " + K.shape + " + (" + B.flatWidth + ")");
|
|
var O = m_Ops.Conv2DTrans(X, K, B, stride, pad, outputAdjustment, fusedActivation);
|
|
LogOutputTensorSummary(O, Prefix + "Conv2DTrans");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Upsample2D(Tensor X, int[] scale, bool bilinear)
|
|
{
|
|
var O = m_Ops.Upsample2D(X, scale, bilinear);
|
|
LogLayerSummary(X.shape + " ^ " + (bilinear ? "bilinear" : "") + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "Upsample2D");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Upsample3D(Tensor X, int[] scale, bool trilinear)
|
|
{
|
|
var O = m_Ops.Upsample3D(X, scale, trilinear);
|
|
LogLayerSummary(X.shape + " ^ " + (trilinear ? "trilinear" : "") + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "Upsample3D");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Resample2D(Tensor X, int[] size, bool bilinear)
|
|
{
|
|
var O = m_Ops.Resample2D(X, size, bilinear);
|
|
LogLayerSummary(X.shape + " ^ " + (bilinear ? "bilinear" : "") + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "Resample2D");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.DepthToSpace(Tensor X, int[] scale, Layer.DepthToSpaceMode mode)
|
|
{
|
|
var O = m_Ops.DepthToSpace(X, scale, mode);
|
|
LogLayerSummary(X.shape + " ^ " + mode + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "DepthToSpace");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.SpaceToDepth(Tensor X, int[] scale)
|
|
{
|
|
var O = m_Ops.SpaceToDepth(X, scale);
|
|
LogLayerSummary(X.shape + " ^ " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "SpaceToDepth");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.MaxPool2D(Tensor X, int[] pool, int[] stride, int[] pad)
|
|
{
|
|
var O = m_Ops.MaxPool2D(X, pool, stride, pad);
|
|
LogLayerSummary(X.shape + " > " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "MaxPool2D");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.AvgPool2D(Tensor X, int[] pool, int[] stride, int[] pad)
|
|
{
|
|
var O = m_Ops.AvgPool2D(X, pool, stride, pad);
|
|
LogLayerSummary(X.shape + " ≥ " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "AvgPool2D");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.GlobalMaxPool2D(Tensor X)
|
|
{
|
|
var O = m_Ops.GlobalMaxPool2D(X);
|
|
LogLayerSummary(X.shape + " >> " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "GlobalMaxPool2D");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.GlobalAvgPool2D(Tensor X)
|
|
{
|
|
var O = m_Ops.GlobalAvgPool2D(X);
|
|
LogLayerSummary(X.shape + " ≥≥ " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "GlobalAvgPool2D");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.GlobalAvgVariancePool2D(Tensor X)
|
|
{
|
|
var O = m_Ops.GlobalAvgVariancePool2D(X);
|
|
LogLayerSummary(X.shape + " ≥≥ " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "GlobalAvgVariancePool2D");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Border2D(Tensor X, int[] pad, float value)
|
|
{
|
|
LogLayerSummary($"{X.shape} ¶(border) value={value} pad=[{pad[0]},{pad[1]},{pad[2]},{pad[3]})");
|
|
var O = m_Ops.Border2D(X, pad, value);
|
|
LogOutputTensorSummary(O, Prefix + "Border2D");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Border3D(Tensor X, int[] pad, float value)
|
|
{
|
|
LogLayerSummary($"{X.shape} ¶(border3d) value={value} pad=[{pad[0]},{pad[1]},{pad[2]},{pad[3]},{pad[4]},{pad[5]})");
|
|
var O = m_Ops.Border3D(X, pad, value);
|
|
LogOutputTensorSummary(O, Prefix + "Border3D");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Pad2DReflect(Tensor X, int[] pad)
|
|
{
|
|
LogLayerSummary($"{X.shape} ¶(reflect) pad=[{pad[0]},{pad[1]},{pad[2]},{pad[3]})");
|
|
var O = m_Ops.Pad2DReflect(X, pad);
|
|
LogOutputTensorSummary(O, Prefix + "Pad2DReflect");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Pad2DSymmetric(Tensor X, int[] pad)
|
|
{
|
|
LogLayerSummary($"{X.shape} ¶(symmetric) pad=[{pad[0]},{pad[1]},{pad[2]},{pad[3]})");
|
|
var O = m_Ops.Pad2DSymmetric(X, pad);
|
|
LogOutputTensorSummary(O, Prefix + "Pad2DSymmetric");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Pad2DEdge(Tensor X, int[] pad)
|
|
{
|
|
LogLayerSummary($"{X.shape} ¶(edge) pad=[{pad[0]},{pad[1]},{pad[2]},{pad[3]})");
|
|
var O = m_Ops.Pad2DEdge(X, pad);
|
|
LogOutputTensorSummary(O, Prefix + "Pad2DEdge");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.ScaleBias(Tensor X, Tensor S, Tensor B)
|
|
{
|
|
LogLayerSummary(X.shape + " * (" + S.channels + ") + (" + B.channels + ")");
|
|
var O = m_Ops.ScaleBias(X, S, B);
|
|
LogOutputTensorSummary(O, Prefix + "ScaleBias");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Normalization(Tensor X, Tensor S, Tensor B, int pool, int axis, float epsilon, Layer.FusedActivation fusedActivation)
|
|
{
|
|
LogLayerSummary(X.shape + " ! " + (pool==1 ? "instance": "batch") + " axis=" + axis);
|
|
var O = m_Ops.Normalization(X, S, B, pool, axis, epsilon, fusedActivation);
|
|
LogOutputTensorSummary(O, Prefix + "Normalization");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.LRN(Tensor X, float alpha, float beta, float bias, int size)
|
|
{
|
|
LogLayerSummary(X.shape + " LRN n=" + size + " a=" + alpha + " b=" + beta + " bias=" + bias);
|
|
var O = m_Ops.LRN(X, alpha, beta, bias, size);
|
|
LogOutputTensorSummary(O, Prefix + "LRN");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Dropout(Tensor X, float alpha)
|
|
{
|
|
LogLayerSummary(X.shape + " a=" + alpha);
|
|
var O = m_Ops.Dropout(X, alpha);
|
|
LogOutputTensorSummary(O, Prefix + "Dropout");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.RandomNormal(TensorShape s, float mean, float scale, int seed)
|
|
{
|
|
LogLayerSummary(s + " N m=" + mean + " s=" + scale + " s=" + seed);
|
|
var O = m_Ops.RandomNormal(s, mean, scale, seed);
|
|
LogOutputTensorSummary(O, Prefix + "RandomNormal");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.RandomUniform(TensorShape s, float mean, float scale, int seed)
|
|
{
|
|
LogLayerSummary(s + " U m=" + mean + " s=" + scale + " s=" + seed);
|
|
var O = m_Ops.RandomUniform(s, mean, scale, seed);
|
|
LogOutputTensorSummary(O, Prefix + "RandomUniform");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Multinomial(Tensor X, int count, int seed)
|
|
{
|
|
LogLayerSummary(X.shape + " M n=" + count + " s=" + seed);
|
|
var O = m_Ops.Multinomial(X, count, seed);
|
|
LogOutputTensorSummary(O, Prefix + "Multinomial");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.OneHot(Tensor X, int depth, float onValue, float offValue, int inputRank)
|
|
{
|
|
LogLayerSummary(X.shape + " Ω n=" + depth + " 1=" + onValue + " 0=" + offValue);
|
|
var O = m_Ops.OneHot(X, depth, onValue, offValue, inputRank);
|
|
LogOutputTensorSummary(O, Prefix + "OneHot");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.RoiAlign(Tensor X, Tensor rois, Tensor indices, int outputHeight, int outputWidth, int samplingRatio, float spatialScale)
|
|
{
|
|
LogLayerSummary(X.shape + " # " + rois.shape + "-> (" + outputHeight + "," + outputWidth + "," + samplingRatio + "," + spatialScale + ")");
|
|
var O = m_Ops.RoiAlign(X, rois, indices, outputHeight, outputWidth, samplingRatio, spatialScale);
|
|
LogOutputTensorSummary(O, Prefix + "RoiAlign");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.TopKIndices(Tensor X, int k, int axis, bool largest, bool sorted)
|
|
{
|
|
LogLayerSummary($"{X.shape} Ω k={k} a={axis} l={largest} s={sorted}");
|
|
var O = m_Ops.TopKIndices(X, k, axis, largest, sorted);
|
|
LogOutputTensorSummary(O, Prefix + "TopKIndices");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public Tensor TopKValues(Tensor X, Tensor I, int axis)
|
|
{
|
|
LogLayerSummary($"{X.shape} {I.shape} Ω a={axis}");
|
|
var O = m_Ops.TopKValues(X, I, axis);
|
|
LogOutputTensorSummary(O, Prefix + "TopKValues");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public Tensor NonZero(Tensor X)
|
|
{
|
|
LogLayerSummary($"{X.shape} NonZero");
|
|
var O = m_Ops.NonZero(X);
|
|
LogOutputTensorSummary(O, Prefix + "NonZero");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Relu(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Relu(X);
|
|
LogOutputTensorSummary(O, Prefix + "Relu");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Softmax(Tensor X, int axis)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Softmax(X, axis);
|
|
LogOutputTensorSummary(O, Prefix + "Softmax");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.LogSoftmax(Tensor X, int axis)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.LogSoftmax(X, axis);
|
|
LogOutputTensorSummary(O, Prefix + "LogSoftmax");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Tanh(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Tanh(X);
|
|
LogOutputTensorSummary(O, Prefix + "Tanh");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Softplus(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Softplus(X);
|
|
LogOutputTensorSummary(O, Prefix + "Softplus");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Sigmoid(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Sigmoid(X);
|
|
LogOutputTensorSummary(O, Prefix + "Sigmoid");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.HardSigmoid(Tensor X, float alpha, float beta)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.HardSigmoid(X, alpha, beta);
|
|
LogOutputTensorSummary(O, Prefix + "HardSigmoid");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Relu6(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Relu6(X);
|
|
LogOutputTensorSummary(O, Prefix + "Relu6");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Elu(Tensor X, float alpha)
|
|
{
|
|
LogLayerSummary(X.shape + " () a=" + alpha);
|
|
var O = m_Ops.Elu(X, alpha);
|
|
LogOutputTensorSummary(O, Prefix + "Elu");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.LeakyRelu(Tensor X, float alpha)
|
|
{
|
|
LogLayerSummary(X.shape + " () a=" + alpha);
|
|
var O = m_Ops.LeakyRelu(X, alpha);
|
|
LogOutputTensorSummary(O, Prefix + "LeakyRelu");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Selu(Tensor X, float alpha, float gamma)
|
|
{
|
|
LogLayerSummary(X.shape + " () a=" + alpha + " g=" + gamma);
|
|
var O = m_Ops.Selu(X, alpha, gamma);
|
|
LogOutputTensorSummary(O, Prefix + "Selu");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.PRelu(Tensor X, Tensor S)
|
|
{
|
|
LogLayerSummary(X.shape + " * (" + S.channels + ")");
|
|
var O = m_Ops.PRelu(X, S);
|
|
LogOutputTensorSummary(O, Prefix + "PRelu");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Swish(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Swish(X);
|
|
LogOutputTensorSummary(O, Prefix + "Swish");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Abs(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Abs(X);
|
|
LogOutputTensorSummary(O, Prefix + "Abs");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Neg(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Neg(X);
|
|
LogOutputTensorSummary(O, Prefix + "Neg");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Ceil(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Ceil(X);
|
|
LogOutputTensorSummary(O, Prefix + "Ceil");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Clip(Tensor X, float min, float max)
|
|
{
|
|
LogLayerSummary(X.shape + " () min=" + min + " max=" + max);
|
|
var O = m_Ops.Clip(X, min, max);
|
|
LogOutputTensorSummary(O, Prefix + "Clip");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Floor(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Floor(X);
|
|
LogOutputTensorSummary(O, Prefix + "Floor");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Round(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Round(X);
|
|
LogOutputTensorSummary(O, Prefix + "Round");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Reciprocal(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Reciprocal(X);
|
|
LogOutputTensorSummary(O, Prefix + "Reciprocal");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Pow(Tensor X, float alpha)
|
|
{
|
|
LogLayerSummary(X.shape + " () a=" + alpha);
|
|
var O = m_Ops.Pow(X, alpha);
|
|
LogOutputTensorSummary(O, Prefix + "Pow");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Exp(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Exp(X);
|
|
LogOutputTensorSummary(O, Prefix + "Exp");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Log(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Log(X);
|
|
LogOutputTensorSummary(O, Prefix + "Log");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Sqrt(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Sqrt(X);
|
|
LogOutputTensorSummary(O, Prefix + "Sqrt");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Acos(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Acos(X);
|
|
LogOutputTensorSummary(O, Prefix + "Acos");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Acosh(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Acosh(X);
|
|
LogOutputTensorSummary(O, Prefix + "Acosh");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Asin(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Asin(X);
|
|
LogOutputTensorSummary(O, Prefix + "Asin");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Asinh(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Asinh(X);
|
|
LogOutputTensorSummary(O, Prefix + "Asinh");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Atan(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Atan(X);
|
|
LogOutputTensorSummary(O, Prefix + "Atan");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Atanh(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Atanh(X);
|
|
LogOutputTensorSummary(O, Prefix + "Atanh");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Cos(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Cos(X);
|
|
LogOutputTensorSummary(O, Prefix + "Cos");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Cosh(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Cosh(X);
|
|
LogOutputTensorSummary(O, Prefix + "Cosh");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Sin(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Sin(X);
|
|
LogOutputTensorSummary(O, Prefix + "Sin");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Sinh(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Sinh(X);
|
|
LogOutputTensorSummary(O, Prefix + "Sinh");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Tan(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Tan(X);
|
|
LogOutputTensorSummary(O, Prefix + "Tan");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Erf(Tensor X)
|
|
{
|
|
LogLayerSummary(X.shape + " ()");
|
|
var O = m_Ops.Erf(X);
|
|
LogOutputTensorSummary(O, Prefix + "Erf");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Add(Tensor[] tensors)
|
|
{
|
|
var O = m_Ops.Add(tensors);
|
|
LogLayerSummary("{" + tensors.Length + "} + " + O.shape); // @TODO: print input dimensions
|
|
LogOutputTensorSummary(O, Prefix + "Add");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Sub(Tensor[] tensors)
|
|
{
|
|
var O = m_Ops.Sub(tensors);
|
|
LogLayerSummary("{" + tensors.Length + "} - " + O.shape); // @TODO: print input dimensions
|
|
LogOutputTensorSummary(O, Prefix + "Sub");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Mul(Tensor[] tensors)
|
|
{
|
|
var O = m_Ops.Mul(tensors);
|
|
LogLayerSummary("{" + tensors.Length + "} * " + O.shape); // @TODO: print input dimensions
|
|
LogOutputTensorSummary(O, Prefix + "Mul");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Div(Tensor[] tensors)
|
|
{
|
|
var O = m_Ops.Div(tensors);
|
|
LogLayerSummary("{" + tensors.Length + "} / " + O.shape); // @TODO: print input dimensions
|
|
LogOutputTensorSummary(O, Prefix + "Div");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Pow(Tensor[] tensors)
|
|
{
|
|
var O = m_Ops.Pow(tensors);
|
|
LogLayerSummary("{" + tensors.Length + "} ^ " + O.shape); // @TODO: print input dimensions
|
|
LogOutputTensorSummary(O, Prefix + "Pow");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Min(Tensor[] tensors)
|
|
{
|
|
var O = m_Ops.Min(tensors);
|
|
LogLayerSummary("{" + tensors.Length + "} < " + O.shape); // @TODO: print input dimensions
|
|
LogOutputTensorSummary(O, Prefix + "Min");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Max(Tensor[] tensors)
|
|
{
|
|
var O = m_Ops.Max(tensors);
|
|
LogLayerSummary("{" + tensors.Length + "} > " + O.shape); // @TODO: print input dimensions
|
|
LogOutputTensorSummary(O, Prefix + "Max");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Mean(Tensor[] tensors)
|
|
{
|
|
var O = m_Ops.Mean(tensors);
|
|
LogLayerSummary("{" + tensors.Length + "} ∑ " + O.shape); // @TODO: print input dimensions
|
|
LogOutputTensorSummary(O, Prefix + "Mean");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.ReduceMax(Tensor X, int axis)
|
|
{
|
|
var O = m_Ops.ReduceMax(X, axis);
|
|
LogLayerSummary(X.shape + " .> " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "ReduceMax");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.ReduceMean(Tensor X, int axis)
|
|
{
|
|
var O = m_Ops.ReduceMean(X, axis);
|
|
LogLayerSummary(X.shape + " .∑ " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "ReduceMean");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.ReduceMin(Tensor X, int axis)
|
|
{
|
|
var O = m_Ops.ReduceMin(X, axis);
|
|
LogLayerSummary(X.shape + " .< " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "ReduceMin");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.ReduceProd(Tensor X, int axis)
|
|
{
|
|
var O = m_Ops.ReduceProd(X, axis);
|
|
LogLayerSummary(X.shape + " .* " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "ReduceProd");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.ReduceSum(Tensor X, int axis)
|
|
{
|
|
var O = m_Ops.ReduceSum(X, axis);
|
|
LogLayerSummary(X.shape + " .+ " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "ReduceSum");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.ArgMax(Tensor X, int axis)
|
|
{
|
|
var O = m_Ops.ArgMax(X, axis);
|
|
LogLayerSummary(X.shape + " .+ " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "ArgMax");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.ArgMin(Tensor X, int axis)
|
|
{
|
|
var O = m_Ops.ArgMin(X, axis);
|
|
LogLayerSummary(X.shape + " .+ " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "ArgMin");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Greater(Tensor a, Tensor b)
|
|
{
|
|
var O = m_Ops.Greater(a, b);
|
|
LogLayerSummary(a.shape + " > " + b.shape + " = " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "Greater");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.GreaterEqual(Tensor a, Tensor b)
|
|
{
|
|
var O = m_Ops.GreaterEqual(a, b);
|
|
LogLayerSummary(a.shape + " >= " + b.shape + " = " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "GreaterEqual");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Less(Tensor a, Tensor b)
|
|
{
|
|
var O = m_Ops.Less(a, b);
|
|
LogLayerSummary(a.shape + " < " + b.shape + " = " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "Less");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.LessEqual(Tensor a, Tensor b)
|
|
{
|
|
var O = m_Ops.LessEqual(a, b);
|
|
LogLayerSummary(a.shape + " <= " + b.shape + " = " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "LessEqual");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Equal(Tensor a, Tensor b)
|
|
{
|
|
var O = m_Ops.Equal(a, b);
|
|
LogLayerSummary(a.shape + " == " + b.shape + " = " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "Equal");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.LogicalOr(Tensor a, Tensor b)
|
|
{
|
|
var O = m_Ops.LogicalOr(a, b);
|
|
LogLayerSummary(a.shape + " || " + b.shape + " = " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "LogicalOr");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.LogicalAnd(Tensor a, Tensor b)
|
|
{
|
|
var O = m_Ops.LogicalAnd(a, b);
|
|
LogLayerSummary(a.shape + " && " + b.shape + " = " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "LogicalAnd");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.LogicalXor(Tensor a, Tensor b)
|
|
{
|
|
var O = m_Ops.LogicalXor(a, b);
|
|
LogLayerSummary(a.shape + " ^ " + b.shape + " = " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "LogicalXor");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.LogicalNot(Tensor x)
|
|
{
|
|
var O = m_Ops.LogicalNot(x);
|
|
LogLayerSummary("!(" + x.shape +" )");
|
|
LogOutputTensorSummary(O, Prefix + "LogicalNot");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Sign(Tensor x)
|
|
{
|
|
var O = m_Ops.Sign(x);
|
|
LogLayerSummary("!(" + x.shape +" )");
|
|
LogOutputTensorSummary(O, Prefix + "Sign");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Where(Tensor c, Tensor a, Tensor b)
|
|
{
|
|
var O = m_Ops.Where(c, a, b);
|
|
LogLayerSummary(c.shape + " ? " + a.shape + ":" + b.shape + " = " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "Where");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Flatten(Tensor X)
|
|
{
|
|
var O = m_Ops.Flatten(X);
|
|
LogLayerSummary(X.shape + " = " + O.shape);
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Reshape(Tensor X, TensorShape shape)
|
|
{
|
|
var O = m_Ops.Reshape(X, shape);
|
|
LogLayerSummary(X.shape + " $ " + O.shape);
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Expand(Tensor X, TensorShape shape)
|
|
{
|
|
var O = m_Ops.Expand(X, shape);
|
|
LogLayerSummary(X.shape + " $ " + O.shape);
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Transpose(Tensor X)
|
|
{
|
|
var O = m_Ops.Transpose(X);
|
|
LogLayerSummary(X.shape + " T " + O.shape);
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Transpose(Tensor X, int[] permutations)
|
|
{
|
|
var O = m_Ops.Transpose(X, permutations);
|
|
LogLayerSummary(X.shape + " T " + O.shape);
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Gather(Tensor[] tensors, int axis)
|
|
{
|
|
var O = m_Ops.Gather(tensors,axis);
|
|
LogLayerSummary("{" + tensors[0].shape + "," + tensors[1].shape + "," + axis + "} # " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "Gather");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.ScatterND(Tensor X, Tensor indices, Tensor updates, Layer.ScatterNDReductionMode reduction)
|
|
{
|
|
var O = m_Ops.ScatterND(X, indices, updates, reduction);
|
|
LogLayerSummary("{" + X.shape + "," + indices.shape + "," + updates.shape + "," + reduction + "} # " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "Gather");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.NonMaxSuppression(Tensor[] tensors, int maxOutputBoxesPerClass, float iouThreshold, float scoreThreshold, int centerPointBox)
|
|
{
|
|
var O = m_Ops.NonMaxSuppression(tensors, maxOutputBoxesPerClass, iouThreshold, scoreThreshold, centerPointBox);
|
|
LogLayerSummary($"{string.Join(",", Enumerable.Select(tensors, t => t.shape.ToString()))} centerPointBox: {centerPointBox} # {O.shape}");
|
|
LogOutputTensorSummary(O, Prefix + nameof(IOps.NonMaxSuppression));
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public Tensor[] LSTM(Tensor X, Tensor[] W, Tensor[] R, Tensor[] Wb, Tensor[] Rb, Tensor hidden, Tensor cell)
|
|
{
|
|
var O = m_Ops.LSTM(X, W, R, Wb, Rb, hidden, cell);
|
|
LogLayerSummary($"X: {X.shape} hidden: {hidden.shape} cell: {cell.shape}");
|
|
LogOutputTensorSummary(O[0], Prefix + nameof(IOps.LSTM));
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Concat(Tensor[] tensors, int axis)
|
|
{
|
|
var O = m_Ops.Concat(tensors, axis);
|
|
LogLayerSummary("{" + tensors.Length + "} # " + O.shape); // @TODO: print input dimensions
|
|
LogOutputTensorSummary(O, Prefix + "Concat");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.StridedSlice(Tensor X, int[] starts, int[] ends, int[] strides)
|
|
{
|
|
var O = m_Ops.StridedSlice(X, starts, ends, strides);
|
|
LogLayerSummary(X.shape + " | " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "StridedSlice");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Tile(Tensor X, int[] repeats)
|
|
{
|
|
var O = m_Ops.Tile(X, repeats);
|
|
LogLayerSummary(X.shape + " % " + O.shape);
|
|
LogOutputTensorSummary(O, Prefix + "Tile");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Shape(Tensor X, int axis)
|
|
{
|
|
LogLayerSummary($"{X.shape}");
|
|
var O = m_Ops.Shape(X, axis);
|
|
LogOutputTensorSummary(O, Prefix + nameof(IOps.Shape));
|
|
return O;
|
|
}
|
|
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.ConstantOfShape(TensorShape X, DataType type, float value)
|
|
{
|
|
LogLayerSummary($"ConstantOfShape {value}");
|
|
var O = m_Ops.ConstantOfShape(X, type, value);
|
|
LogOutputTensorSummary(O, Prefix + nameof(IOps.ConstantOfShape));
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Copy(Tensor x)
|
|
{
|
|
var O = m_Ops.Copy(x);
|
|
LogLayerSummary("!(" + x.shape +" )");
|
|
LogOutputTensorSummary(O, "Copy");
|
|
return O;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.Prepare(Tensor X)
|
|
{
|
|
if (m_UseUnityLogFile)
|
|
D.Log("!" + X.shape);
|
|
return m_Ops.Prepare(X);
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
Tensor IOps.PrepareNoAlloc(Tensor X)
|
|
{
|
|
D.Log("!" + X.shape);
|
|
return m_Ops.PrepareNoAlloc(X);
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
void IOps.ResetAllocator(bool keepCachedMemory)
|
|
{
|
|
m_Ops.ResetAllocator(keepCachedMemory);
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
void IOps.SetModelExecutionsReporter(IModelExecutionsReporter executionsReporter)
|
|
{
|
|
m_Ops.SetModelExecutionsReporter(executionsReporter);
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
IModelExecutionsReporter IOps.GetModelExecutionsReporter()
|
|
{
|
|
return m_Ops.GetModelExecutionsReporter();
|
|
}
|
|
|
|
private void LogLayerSummary(string summary)
|
|
{
|
|
if (m_UseUnityLogFile)
|
|
D.Log(summary);
|
|
#if ENABLE_BARRACUDA_STATS
|
|
m_Ops.GetModelExecutionsReporter()?.SetLayerSummary(summary);
|
|
#endif //ENABLE_BARRACUDA_STATS
|
|
}
|
|
|
|
private void LogOutputTensorSummary(Tensor O, string messagePrefix, int size = 32)
|
|
{
|
|
if (m_UseUnityLogFile)
|
|
O.PrintDataPart(size, messagePrefix);
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace Unity.Barracuda
|