public Tensor NormAll(Tensor result, Tensor src, float value) { var writeTarget = TensorResultBuilder.GetWriteTarget(result, src, false, 1); NativeWrapper.InvokeTypeMatch(normall_func, writeTarget, src, value); return(writeTarget); }
public void AddLayerNormGrad(Tensor result1, Tensor result2, Tensor gradGamma_, Tensor gradBeta_, Tensor adj_, Tensor y_, Tensor x1_, Tensor x2_, Tensor gamma_, Tensor beta_, float eps) { var writeTarget1 = TensorResultBuilder.GetWriteTarget(result1, adj_, false, adj_.Sizes); var writeTarget2 = TensorResultBuilder.GetWriteTarget(result2, adj_, false, adj_.Sizes); NativeWrapper.InvokeTypeMatch(this.addlayerNormGrad_func, writeTarget1, writeTarget2, gradGamma_, gradBeta_, adj_, y_, x1_, x2_, gamma_, beta_, (int)adj_.Sizes[0], (int)adj_.Sizes[1], eps); }
public Tensor LayerNormGrad(Tensor result, Tensor gradGamma_, Tensor gradBeta_, Tensor adj_, Tensor y_, Tensor x_, Tensor gamma_, Tensor beta_, float eps) { var writeTarget = TensorResultBuilder.GetWriteTarget(result, adj_, false, adj_.Sizes); NativeWrapper.InvokeTypeMatch(this.layerNormGrad_func, writeTarget, gradGamma_, gradBeta_, adj_, y_, x_, gamma_, beta_, (int)adj_.Sizes[0], (int)adj_.Sizes[1], eps); return(writeTarget); }
public Tensor AddLayerNorm(Tensor result, Tensor src1, Tensor src2, Tensor gamma_, Tensor beta_, float eps) { var writeTarget = TensorResultBuilder.GetWriteTarget(result, src1, false, src1.Sizes); NativeWrapper.InvokeTypeMatch(this.addlayerNorm_func, writeTarget, src1, src2, gamma_, beta_, eps, (int)src1.Sizes[0], (int)src1.Sizes[1]); return(writeTarget); }
public Tensor Softmax(Tensor result, Tensor src) { Tensor writeTarget = TensorResultBuilder.GetWriteTarget(result, src, false, src.Sizes); NativeWrapper.InvokeTypeMatch(softmax_func, writeTarget, src, (int)src.Sizes[0], (int)src.Sizes[1]); return(writeTarget); }
public Tensor SoftmaxGrad(Tensor grad_, Tensor adj_, Tensor val_, bool addGrad = true) { Tensor writeTarget = TensorResultBuilder.GetWriteTarget(grad_, adj_, false, adj_.Sizes); NativeWrapper.InvokeTypeMatch(softmaxGrad_func, writeTarget, adj_, val_, (int)adj_.Sizes[0], (int)adj_.Sizes[1], addGrad); return(writeTarget); }
public Tensor Gather(Tensor result, Tensor src, int dim, Tensor indices) { if (result != null && result.DimensionCount != src.DimensionCount) { throw new InvalidOperationException("result and src must have same number of dimensions"); } if (result != null && dim < 0 && dim >= result.DimensionCount) { throw new ArgumentOutOfRangeException("dim"); } if (indices.DimensionCount != src.DimensionCount) { throw new InvalidOperationException("src and indices must have same number of dimensions"); } if (result != null && !result.IsSameSizeAs(indices)) { throw new InvalidOperationException("result and indices must be the same size"); } if (result != null && !TensorResultBuilder.ArrayEqualExcept(src.Shape, result.Shape, dim)) { throw new InvalidOperationException("result and src must be the same size except in dimension dim"); } var writeTarget = TensorResultBuilder.GetWriteTarget(result, indices.Allocator, src.ElementType, false, indices.Shape); NativeWrapper.InvokeTypeMatch(gather_func, writeTarget, src, dim, indices); return(writeTarget); }
public Tensor ScatterFill(Tensor result, float value, int dim, Tensor indices) { if (result == null) { throw new ArgumentNullException("result"); } if (dim < 0 && dim >= result.DimensionCount) { throw new ArgumentOutOfRangeException("dim"); } if (indices.DimensionCount != result.DimensionCount) { throw new InvalidOperationException("result and indices must have same number of dimensions"); } if (!TensorResultBuilder.ArrayEqualExcept(indices.Shape, result.Shape, dim)) { throw new InvalidOperationException("result and indices must be the same size except in dimension dim"); } var writeTarget = result; NativeWrapper.InvokeTypeMatch(scatterFill_func, writeTarget, value, dim, indices); return(writeTarget); }
public NDArray Scatter(NDArray result, NDArray src, int dim, NDArray indices) { if (result == null) { throw new ArgumentNullException("result"); } if (result.DimensionCount != src.DimensionCount) { throw new InvalidOperationException("result and src must have same number of dimensions"); } if (dim < 0 && dim >= result.DimensionCount) { throw new ArgumentOutOfRangeException("dim"); } if (indices.DimensionCount != src.DimensionCount) { throw new InvalidOperationException("src and indices must have same number of dimensions"); } if (!src.IsSameSizeAs(indices)) { throw new InvalidOperationException("src and indices must be the same size"); } if (!TensorResultBuilder.ArrayEqualExcept(src.Shape, result.Shape, dim)) { throw new InvalidOperationException("result and src must be the same size except in dimension dim"); } var writeTarget = result; NativeWrapper.InvokeTypeMatch(scatter_func, writeTarget, src, dim, indices); return(writeTarget); }
public Tensor StdAll(Tensor result, Tensor src) { var writeTarget = TensorResultBuilder.GetWriteTarget(result, src, false, 1); NativeWrapper.InvokeTypeMatch(stdall_func, writeTarget, src); return(writeTarget); }
// allArgs should start with a null placeholder for the RNG object /// <summary> /// Invokes the with RNG. /// </summary> /// <param name="seed">The seed.</param> /// <param name="method">The method.</param> /// <param name="allArgs">All arguments.</param> private static void InvokeWithRng(int? seed, MethodInfo method, params object[] allArgs) { if (!seed.HasValue) seed = seedGen.Next(); IntPtr rng; NativeWrapper.CheckResult(CpuOpsNative.TS_NewRNG(out rng)); NativeWrapper.CheckResult(CpuOpsNative.TS_SetRNGSeed(rng, seed.Value)); allArgs[0] = rng; NativeWrapper.InvokeTypeMatch(method, allArgs); NativeWrapper.CheckResult(CpuOpsNative.TS_DeleteRNG(rng)); }
public void Cols2Im(NDArray col, NDArray im, int channels, int height, int width, int patch_h, int patch_w, int pad_h, int pad_w, int stride_h, int stride_w, int dilation_h, int dilation_w) { int height_col = (height + 2 * pad_h - (dilation_h * (patch_h - 1) + 1)) / stride_h + 1; int width_col = (width + 2 * pad_w - (dilation_w * (patch_w - 1) + 1)) / stride_w + 1; NativeWrapper.InvokeTypeMatch(cols2im_func, col, height, width, channels, patch_h, patch_w, pad_h, pad_w, stride_h, stride_w, dilation_h, dilation_w, height_col, width_col, im); }
public void Im2Cols(NDArray im, NDArray col, int channels, int height, int width, int ksize_h, int ksize_w, int pad_h, int pad_w, int stride_h, int stride_w, int dilation_h, int dilation_w) { int height_col = (height + 2 * pad_h - (dilation_h * (ksize_h - 1) + 1)) / stride_h + 1; int width_col = (width + 2 * pad_w - (dilation_w * (ksize_w - 1) + 1)) / stride_w + 1; NativeWrapper.InvokeTypeMatch(im2cols_func, im, height, width, channels, ksize_h, ksize_w, pad_h, pad_w, stride_h, stride_w, dilation_h, dilation_w, height_col, width_col, col); }
public Tensor SoftmaxGrad(Tensor grad_, Tensor adj_, Tensor val_, bool addGrad = true) { var ndim = adj_.DimensionCount; var storageSize = TensorDimensionHelpers.GetStorageSize(adj_.Sizes, adj_.Strides); var cols = adj_.Sizes[ndim - 1]; if (storageSize % cols != 0) { throw new Exception($"Invalid tensor storage size = '{storageSize}', and cols = '{cols}'"); } var rows = storageSize / cols; var writeTarget = TensorResultBuilder.GetWriteTarget(grad_, adj_, false, adj_.Sizes); NativeWrapper.InvokeTypeMatch(this.softmaxGrad_func, writeTarget, adj_, val_, (int)rows, (int)cols, addGrad); return(writeTarget); }
public Tensor Softmax(Tensor result, Tensor src) { var ndim = src.DimensionCount; var storageSize = TensorDimensionHelpers.GetStorageSize(src.Sizes, src.Strides); var cols = src.Sizes[ndim - 1]; if (storageSize % cols != 0) { throw new Exception($"Invalid tensor storage size = '{storageSize}', and cols = '{cols}'"); } var rows = storageSize / cols; var writeTarget = TensorResultBuilder.GetWriteTarget(result, src, false, src.Sizes); NativeWrapper.InvokeTypeMatch(this.softmax_func, writeTarget, src, (int)rows, (int)cols); return(writeTarget); }
public Tensor SoftmaxMask(Tensor result, Tensor src, Tensor mask) { var ndim = src.DimensionCount; var storageSize = TensorDimensionHelpers.GetStorageSize(src.Sizes, src.Strides); var cols = src.Sizes[ndim - 1]; if (storageSize % cols != 0) { throw new Exception($"Invalid tensor storage size = '{storageSize}', and cols = '{cols}'"); } var rows = storageSize / cols; var maskNdim = mask.DimensionCount; var maskStorageSize = TensorDimensionHelpers.GetStorageSize(mask.Sizes, mask.Strides); var maskCols = mask.Sizes[maskNdim - 1]; if (maskStorageSize % maskCols != 0) { throw new Exception($"Invalid mask tensor storage size = '{maskStorageSize}', and cols = '{maskCols}'"); } var maskRows = maskStorageSize / maskCols; if (rows % maskRows != 0) { throw new Exception($"Invalid tensor rows = '{rows}' and mask tensor rows = '{maskRows}'"); } if (cols != maskCols) { throw new Exception($"Tensor cols = '{cols}', mask tensor cols = '{maskCols}'. They should be equal."); } var writeTarget = TensorResultBuilder.GetWriteTarget(result, src, false, src.Sizes); NativeWrapper.InvokeTypeMatch(this.softmaxmask_func, writeTarget, src, mask, (int)rows, (int)cols, (int)maskRows); return(writeTarget); }
public void Fill(Tensor result, float value) { NativeWrapper.InvokeTypeMatch(fill_func, result, value); }
public Tensor Adam(Tensor tw, Tensor tg, Tensor tv, Tensor tm, int batchSize, float step_size, float clipval, float regc, float decay_rate_v, float decay_rate_m, int iter, float eps) { NativeWrapper.InvokeTypeMatch(this.adam_func, tw, tg, tv, tm, (int)tw.Sizes[0], (int)tw.Sizes[1], batchSize, step_size, clipval, regc, decay_rate_v, decay_rate_m, iter, eps); return(tw); }
public Tensor RMSProp(Tensor tw, Tensor tg, Tensor tc, int batchSize, float step_size, float clipval, float regc, float decay_rate, float eps) { NativeWrapper.InvokeTypeMatch(this.rmsProp_func, tw, tg, tc, (int)tw.Sizes[0], (int)tw.Sizes[1], batchSize, step_size, clipval, regc, decay_rate, eps); return(tw); }
public Tensor UpdateCost(Tensor tw, Tensor tids, Tensor tc) { NativeWrapper.InvokeTypeMatch(this.updatecost_func, tw, tids, tc, (int)tw.Sizes[0], (int)tw.Sizes[1]); return(tw); }