public static void NeedPreviousBackwardCpu(this ICompressibleActivation compressibleActivation, NdArray y, NdArray x) { for (int i = 0; i < x.Grad.Length; i++) { x.Grad[i] += compressibleActivation.BackwardActivate(y.Grad[i], y.Data[i]); } }
public Convolution2D(int inputChannels, int outputChannels, int[] kernelSize, int[] stride = null, int[] pad = null, bool noBias = false, Array initialW = null, Array initialb = null, ICompressibleActivation <T> activation = null, string name = FUNCTION_NAME, string[] inputNames = null, string[] outputNames = null) : base(name, inputNames, outputNames) { if (pad == null) { pad = new[] { 0, 0 } } ; if (stride == null) { stride = new[] { 1, 1 } } ; this.Weight = new NdArray <T>(outputChannels, inputChannels, kernelSize[1], kernelSize[0]); if (!noBias) { this.Bias = new NdArray <T>(outputChannels); } this.StrideX = stride[0]; this.StrideY = stride[1]; this.PadX = pad[0]; this.PadY = pad[1]; this.Parameters = new NdArray <T> [noBias ? 1: 2]; this.Activation = activation; this.Initialize(initialW, initialb); InitFunc(new StreamingContext()); }
public static NdArray <Real> NeedPreviousForwardGpu(this ICompressibleActivation <Real> compressibleActivation, NdArray <Real> x) { Real[] y = new Real[x.Data.Length]; using (ComputeBuffer <Real> gpuX = new ComputeBuffer <Real>(OpenCL.Context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, x.Data)) using (ComputeBuffer <Real> gpuY = new ComputeBuffer <Real>(OpenCL.Context, ComputeMemoryFlags.WriteOnly | ComputeMemoryFlags.AllocateHostPointer, y.Length)) { compressibleActivation.ForwardKernel.SetMemoryArgument(0, gpuX); compressibleActivation.ForwardKernel.SetMemoryArgument(1, gpuY); OpenCL.CommandQueue.Execute ( compressibleActivation.ForwardKernel, null, new long[] { x.Data.Length }, null, null ); OpenCL.CommandQueue.Finish(); OpenCL.CommandQueue.ReadFromBuffer(gpuY, ref y, true, null); } return(NdArray.Convert(y, x.Shape, x.BatchCount, compressibleActivation)); }
public static bool SetParallel <T>(this ICompressibleActivation <T> compressibleActivation, bool enable, KeyValuePair <string, string>[] activationParameters = null) where T : unmanaged, IComparable <T> { compressibleActivation.IsParallel = enable & OpenCL.Enable; if (compressibleActivation.IsParallel) { string kernelNameBase = compressibleActivation.FunctionName.Replace(" ", ""); compressibleActivation.ActivateKernelString = OpenCL.GetKernelSource(Resources.Activation).Replace("/*kernelNameBase*/", kernelNameBase); compressibleActivation.ForwardKernelName = kernelNameBase + "Forward"; compressibleActivation.BackwardKernelName = kernelNameBase + "Backward"; string kernelSource = compressibleActivation.KernelSource; if (activationParameters != null) { foreach (var parameter in activationParameters) { kernelSource = kernelSource.Replace(parameter.Key, parameter.Value); } } kernelSource += compressibleActivation.ActivateKernelString; ComputeProgram program = OpenCL.CreateProgram <T>(kernelSource); compressibleActivation.ForwardKernel = program.CreateKernel(compressibleActivation.ForwardKernelName); compressibleActivation.BackwardKernel = program.CreateKernel(compressibleActivation.BackwardKernelName); } return(compressibleActivation.IsParallel); }
public Linear(int inputCount, int outputCount, bool noBias = false, Array initialW = null, Array initialb = null, ICompressibleActivation <T> activation = null, string name = FUNCTION_NAME, string[] inputNames = null, string[] outputNames = null) : base(name, inputNames, outputNames) { this.Weight = new NdArray <T>(outputCount, inputCount); this.Weight.Name = this.Name + " Weight"; this.Parameters = new NdArray <T> [noBias ? 1: 2]; this.Activation = activation; if (initialW == null) { Initializer.InitHeNorm(this.Weight); } else { this.Weight.Data = initialW.FlattenEx <T>(); } this.Parameters[0] = this.Weight; if (!noBias) { this.Bias = new NdArray <T>(outputCount); this.Bias.Name = this.Name + " Bias"; if (initialb != null) { this.Bias.Data = initialb.FlattenEx <T>(); } this.Parameters[1] = this.Bias; } InitFunc(new StreamingContext()); }
public static void NeedPreviousBackwardGpu(this ICompressibleActivation <Real> compressibleActivation, NdArray <Real> y, NdArray <Real> x) { Real[] gx = new Real[y.Grad.Length]; using (ComputeBuffer <Real> gpugY = new ComputeBuffer <Real>(OpenCL.Context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, y.Grad)) using (ComputeBuffer <Real> gpuY = new ComputeBuffer <Real>(OpenCL.Context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, y.Data)) using (ComputeBuffer <Real> gpugX = new ComputeBuffer <Real>(OpenCL.Context, ComputeMemoryFlags.WriteOnly | ComputeMemoryFlags.AllocateHostPointer, gx.Length)) { compressibleActivation.BackwardKernel.SetMemoryArgument(0, gpugY); compressibleActivation.BackwardKernel.SetMemoryArgument(1, gpuY); compressibleActivation.BackwardKernel.SetMemoryArgument(2, gpugX); OpenCL.CommandQueue.Execute ( compressibleActivation.BackwardKernel, null, new long[] { y.Grad.Length }, null, null ); OpenCL.CommandQueue.Finish(); OpenCL.CommandQueue.ReadFromBuffer(gpugX, ref gx, true, null); } for (int i = 0; i < x.Grad.Length; i++) { x.Grad[i] += gx[i]; } }
public Deconvolution2D(int inputChannels, int outputChannels, int[] kernelSize, int[] subSample = null, int[] trim = null, bool noBias = false, Array initialW = null, Array initialb = null, ICompressibleActivation activation = null, string name = FUNCTION_NAME, string[] inputNames = null, string[] outputNames = null) : base(name, inputNames, outputNames) { if (subSample == null) { subSample = new[] { 1, 1 } } ; if (trim == null) { trim = new[] { 0, 0 } } ; this.KernelWidth = kernelSize[0]; this.KernelHeight = kernelSize[1]; this.PadX = trim[0]; this.PadY = trim[1]; this.NoBias = noBias; this.StrideX = subSample[0]; this.StrideY = subSample[1]; this.Parameters = new NdArray[noBias ? 1 : 2]; this.OutputCount = outputChannels; this.InputCount = inputChannels; this.Activation = activation; this.Initialize(initialW, initialb); }
public Linear(CPU.Linear <T> linear) : base(linear.Name, linear.InputNames, linear.OutputNames) { this.Weight = linear.Weight; this.Bias = linear.Bias; this.Parameters = linear.Parameters; this.Activation = (ICompressibleActivation <T>)CLConverter.Convert(linear.Activation); this.SetParallel(true); }
public static Real[] GetActivatedgy(this ICompressibleActivation <Real> compressibleActivation, NdArray <Real> y, NdArray <Real> x) { Real[] activatedgy = new Real[y.Grad.Length]; for (int i = 0; i < activatedgy.Length; i++) { activatedgy[i] = compressibleActivation.BackwardActivate(y.Grad[i], y.Data[i], x.Data[i]); } return(activatedgy); }
public static NdArray NeedPreviousForwardCpu(this ICompressibleActivation compressibleActivation, NdArray x) { Real[] y = new Real[x.Data.Length]; for (int i = 0; i < y.Length; i++) { y[i] = compressibleActivation.ForwardActivate(x.Data[i]); } return(NdArray.Convert(y, x.Shape, x.BatchCount, compressibleActivation)); }
public static string GetActivateSource(this ICompressibleActivation compressibleActivation) { string activationSource = compressibleActivation.KernelSource; if (compressibleActivation.ActivationParameters != null) { foreach (var activationParameter in compressibleActivation.ActivationParameters) { activationSource = activationSource.Replace(activationParameter.Key, activationParameter.Value); } } return(activationSource); }
public Convolution2D(Linear <T> linear) : base(linear.Name, linear.InputNames, linear.OutputNames) { this.StrideX = 1; this.StrideY = 1; this.PadX = 0; this.PadY = 0; this.Parameters = linear.Parameters; this.Weight = linear.Weight; this.Weight.Reshape(this.Weight.Shape[0], this.Weight.Shape[1], 1, 1); this.Bias = linear.Bias; this.Activation = linear.Activation; InitFunc(new StreamingContext()); }
//Convert public Convolution2D(CPU.Convolution2D <T> conv2d) : base(conv2d.Name, conv2d.InputNames, conv2d.OutputNames) { this.StrideX = conv2d.StrideX; this.StrideY = conv2d.StrideY; this.PadX = conv2d.PadX; this.PadY = conv2d.PadY; this.Weight = conv2d.Weight; this.Bias = conv2d.Bias; this.Parameters = conv2d.Parameters; this.Activation = (ICompressibleActivation <T>)CLConverter.Convert(conv2d.Activation); this.SetParallel(true); this.InitFunc(new StreamingContext()); }
public Convolution2D(Linear linear) : base(linear.Name, linear.InputNames, linear.OutputNames) { this.KernelWidth = 1; this.KernelHeight = 1; this.StrideX = 1; this.StrideY = 1; this.PadX = 0; this.PadY = 0; this.Parameters = linear.Parameters; this.Weight = linear.Weight; this.Weight.Reshape(OutputCount, InputCount, this.KernelHeight, this.KernelWidth); this.Bias = linear.Bias; this.NoBias = linear.NoBias; this.Activation = linear.Activation; }
public Deconvolution2D(CPU.Deconvolution2D <T> deconv2D) : base(deconv2D.Name, deconv2D.InputNames, deconv2D.OutputNames) { this.PadX = deconv2D.PadX; this.PadY = deconv2D.PadY; this.StrideX = deconv2D.StrideX; this.StrideY = deconv2D.StrideY; this.Weight = deconv2D.Weight; this.Bias = deconv2D.Bias; this.Parameters = deconv2D.Parameters; this.Activation = (ICompressibleActivation <T>)CLConverter.Convert(deconv2D.Activation); this.SetParallel(true); this.InitFunc(new StreamingContext()); }
public Deconvolution2D(int inputChannels, int outputChannels, int kernelSize, int stride = 1, int pad = 0, bool noBias = false, Array initialW = null, Array initialb = null, ICompressibleActivation activation = null, string name = FUNCTION_NAME, string[] inputNames = null, string[] outputNames = null) : base(name, inputNames, outputNames) { this.KernelWidth = kernelSize; this.KernelHeight = kernelSize; this.PadX = pad; this.PadY = pad; this.StrideX = stride; this.StrideY = stride; this.NoBias = noBias; this.Parameters = new NdArray[noBias ? 1 : 2]; this.OutputCount = outputChannels; this.InputCount = inputChannels; this.Activation = activation; this.Initialize(initialW, initialb); }
public Convolution2D(int inputChannels, int outputChannels, int kernelSize, int stride = 1, int pad = 0, bool noBias = false, Array initialW = null, Array initialb = null, ICompressibleActivation <T> activation = null, string name = FUNCTION_NAME, string[] inputNames = null, string[] outputNames = null) : base(name, inputNames, outputNames) { this.StrideX = stride; this.StrideY = stride; this.PadX = pad; this.PadY = pad; this.Parameters = new NdArray <T> [noBias ? 1: 2]; this.Weight = new NdArray <T>(outputChannels, inputChannels, kernelSize, kernelSize); if (!noBias) { this.Bias = new NdArray <T>(outputChannels); } this.Activation = activation; this.Initialize(initialW, initialb); InitFunc(new StreamingContext()); }
public Linear(int inputCount, int outputCount, bool noBias = false, Array initialW = null, Array initialb = null, ICompressibleActivation activation = null, string name = FUNCTION_NAME, string[] inputNames = null, string[] outputNames = null) : base(name, inputNames, outputNames) { this.OutputCount = outputCount; this.InputCount = inputCount; this.Weight = new NdArray(outputCount, inputCount); this.Weight.Name = this.Name + " Weight"; this.NoBias = noBias; this.Parameters = new NdArray[noBias ? 1 : 2]; this.Activation = activation; if (initialW == null) { Initializer.InitWeight(this.Weight); } else { this.Weight.Data = Real.ToRealArray(initialW); } this.Parameters[0] = this.Weight; if (!noBias) { this.Bias = new NdArray(outputCount); this.Bias.Name = this.Name + " Bias"; if (initialb != null) { this.Bias.Data = Real.ToRealArray(initialb); } this.Parameters[1] = this.Bias; } }
public static void SingleOutputBackward(NdArray <Real> y, NdArray <Real> x, NdArray <Real> weight, NdArray <Real> bias, int strideX, int strideY, int padX, int padY, ComputeKernel backwardgWKernel, ComputeKernel backwardgXKernel, ICompressibleActivation <Real> activation) { int inputCount = weight.Shape[0]; int outputCount = weight.Shape[1]; int kernelHeight = weight.Shape[2]; int kernelWidth = weight.Shape[3]; Real[] gx = new Real[x.Data.Length]; Real[] activatedgy = activation != null?activation.GetActivatedgy(y, x) : y.Grad; if (bias != null) { Deconvolution2DFunc.CalcBiasGrad(activatedgy, bias.Grad, y.Shape, y.BatchCount); } //gyは共通で使用 using (ComputeBuffer <Real> gpugY = new ComputeBuffer <Real>(OpenCL.Context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, activatedgy)) { using (ComputeBuffer <Real> gpugW = new ComputeBuffer <Real>(OpenCL.Context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.UseHostPointer, weight.Grad)) using (ComputeBuffer <Real> gpuX = new ComputeBuffer <Real>(OpenCL.Context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, x.Data)) { backwardgWKernel.SetMemoryArgument(0, gpugY); backwardgWKernel.SetMemoryArgument(1, gpuX); backwardgWKernel.SetMemoryArgument(2, gpugW); backwardgWKernel.SetValueArgument(3, y.BatchCount); backwardgWKernel.SetValueArgument(4, outputCount); backwardgWKernel.SetValueArgument(5, y.Length); backwardgWKernel.SetValueArgument(6, y.Shape[1]); backwardgWKernel.SetValueArgument(7, y.Shape[2]); backwardgWKernel.SetValueArgument(8, x.Shape[1]); backwardgWKernel.SetValueArgument(9, x.Shape[2]); backwardgWKernel.SetValueArgument(10, x.Length); backwardgWKernel.SetValueArgument(11, strideX); backwardgWKernel.SetValueArgument(12, strideY); backwardgWKernel.SetValueArgument(13, padX); backwardgWKernel.SetValueArgument(14, padY); backwardgWKernel.SetValueArgument(15, kernelHeight); backwardgWKernel.SetValueArgument(16, kernelWidth); OpenCL.CommandQueue.Execute ( backwardgWKernel, null, new long[] { inputCount *outputCount, kernelHeight, kernelWidth }, null, null ); OpenCL.CommandQueue.Finish(); OpenCL.CommandQueue.ReadFromBuffer(gpugW, ref weight.Grad, true, null); } using (ComputeBuffer <Real> gpugX = new ComputeBuffer <Real>(OpenCL.Context, ComputeMemoryFlags.WriteOnly | ComputeMemoryFlags.AllocateHostPointer, gx.Length)) using (ComputeBuffer <Real> gpuW = new ComputeBuffer <Real>(OpenCL.Context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, weight.Data)) { backwardgXKernel.SetMemoryArgument(0, gpugY); backwardgXKernel.SetMemoryArgument(1, gpuW); backwardgXKernel.SetMemoryArgument(2, gpugX); backwardgXKernel.SetValueArgument(3, outputCount); backwardgXKernel.SetValueArgument(4, inputCount); backwardgXKernel.SetValueArgument(5, y.Length); backwardgXKernel.SetValueArgument(6, y.Shape[1]); backwardgXKernel.SetValueArgument(7, y.Shape[2]); backwardgXKernel.SetValueArgument(8, x.Shape[1]); backwardgXKernel.SetValueArgument(9, x.Shape[2]); backwardgXKernel.SetValueArgument(10, x.Length); backwardgXKernel.SetValueArgument(11, strideX); backwardgXKernel.SetValueArgument(12, strideY); backwardgXKernel.SetValueArgument(13, padX); backwardgXKernel.SetValueArgument(14, padY); backwardgXKernel.SetValueArgument(15, kernelHeight); backwardgXKernel.SetValueArgument(16, kernelWidth); OpenCL.CommandQueue.Execute ( backwardgXKernel, null, new long[] { x.BatchCount *x.Shape[0], x.Shape[1], x.Shape[2] }, null, null ); OpenCL.CommandQueue.Finish(); OpenCL.CommandQueue.ReadFromBuffer(gpugX, ref gx, true, null); } } for (int i = 0; i < x.Grad.Length; i++) { x.Grad[i] += gx[i]; } }
public static void SingleOutputBackward(NdArray <Real> y, NdArray <Real> x, NdArray <Real> weight, NdArray <Real> bias, ICompressibleActivation <Real> activation) { int outputCount = weight.Shape[0]; int inputCount = weight.Shape[1]; Real[] activatedgy = activation != null?activation.GetActivatedgy(y, x) : y.Grad; if (bias != null) { CalcBiasGrad(activatedgy, y.BatchCount, outputCount, bias.Grad); } for (int batchCount = 0; batchCount < y.BatchCount; batchCount++) { for (int i = 0; i < outputCount; i++) { Real gyData = activatedgy[i + batchCount * outputCount]; for (int j = 0; j < inputCount; j++) { weight.Grad[i * inputCount + j] += x.Data[batchCount * inputCount + j] * gyData; x.Grad[batchCount * inputCount + j] += weight.Data[i * inputCount + j] * gyData; } } } }
public static NdArray <Real> SingleInputForward(NdArray <Real> x, NdArray <Real> weight, NdArray <Real> bias, ICompressibleActivation <Real> activation, IFunction <Real> linear) { int outputCount = weight.Shape[0]; int inputCount = weight.Shape[1]; Real[] y = bias == null ? new Real[outputCount * x.BatchCount] : GetBiasedValue(x.BatchCount, outputCount, bias.Data); for (int batchCount = 0; batchCount < x.BatchCount; batchCount++) { for (int i = 0; i < outputCount; i++) { for (int j = 0; j < inputCount; j++) { y[batchCount * outputCount + i] += x.Data[batchCount * inputCount + j] * weight.Data[i * inputCount + j]; } } } if (activation != null) { for (int i = 0; i < y.Length; i++) { y[i] = activation.ForwardActivate(y[i]); } } return(NdArray.Convert(y, new[] { outputCount }, x.BatchCount, linear)); }
public Linear(int inputCount, int outputCount, bool noBias = false, Array initialW = null, T[] initialb = null, Action <NdArray <T> > weightInitializer = null, ICompressibleActivation <T> activation = null, string name = "Linear", string[] inputNames = null, string[] outputNames = null, bool gpuEnable = false) : base(inputCount, outputCount, noBias, initialW, initialb, weightInitializer, activation, name, inputNames, outputNames) { this.SetParallel(gpuEnable); }
public static NdArray <Real> SingleInputForward(NdArray <Real> x, NdArray <Real> weight, NdArray <Real> bias, int strideX, int strideY, int padX, int padY, ICompressibleActivation <Real> activation, IFunction <Real> conv2d) { int outputCount = weight.Shape[0]; int inputCount = weight.Shape[1]; int kernelHeight = weight.Shape[2]; int kernelWidth = weight.Shape[3]; int outputHeight = (int)Math.Floor((x.Shape[1] - kernelHeight + padY * 2.0f) / strideY) + 1; int outputWidth = (int)Math.Floor((x.Shape[2] - kernelWidth + padX * 2.0f) / strideX) + 1; Real[] y = new Real[x.BatchCount * outputCount * outputHeight * outputWidth]; for (int batchCounter = 0; batchCounter < x.BatchCount; batchCounter++) { int yBatchOffset = batchCounter * outputCount * outputHeight * outputWidth; int xBatchOffset = batchCounter * x.Length; for (int och = 0; och < outputCount; och++) { int kOchOffset = och * inputCount * kernelHeight * kernelWidth; int yChOffset = yBatchOffset + och * outputHeight * outputWidth; for (int oy = 0; oy < outputHeight * strideY; oy += strideY) { int iyStart = oy - padY < 0 ? 0 : oy - padY; int iyLimit = kernelHeight + oy - padY < x.Shape[1] ? kernelHeight + oy - padY : x.Shape[1]; for (int ox = 0; ox < outputWidth * strideX; ox += strideX) { int ixStart = ox - padX < 0 ? 0 : ox - padX; int ixLimit = kernelWidth + ox - padX < x.Shape[2] ? kernelWidth + ox - padX : x.Shape[2]; int yIndex = yChOffset + oy / strideY * outputWidth + ox / strideX; for (int ich = 0; ich < inputCount; ich++) { int kIchOffset = kOchOffset + ich * kernelHeight * kernelWidth; int xChOffset = xBatchOffset + ich * x.Shape[1] * x.Shape[2]; for (int iy = iyStart; iy < iyLimit; iy++) { for (int ix = ixStart; ix < ixLimit; ix++) { int wIndex = kIchOffset + (iy - oy + padY) * kernelWidth + ix - ox + padX; int xIndex = xChOffset + iy * x.Shape[2] + ix; y[yIndex] += x.Data[xIndex] * weight.Data[wIndex]; } } } } } } } if (activation != null && bias != null) { for (int batchCounter = 0; batchCounter < x.BatchCount; batchCounter++) { int resultIndex = batchCounter * outputCount * outputHeight * outputWidth; for (int och = 0; och < outputCount; och++) { for (int location = 0; location < outputHeight * outputWidth; location++) { y[resultIndex] += bias.Data[och]; y[resultIndex] = activation.ForwardActivate(y[resultIndex]); resultIndex++; } } } } else if (bias != null) { for (int batchCounter = 0; batchCounter < x.BatchCount; batchCounter++) { int resultIndex = batchCounter * outputCount * outputHeight * outputWidth; for (int och = 0; och < outputCount; och++) { for (int location = 0; location < outputHeight * outputWidth; location++) { y[resultIndex] += bias.Data[och]; resultIndex++; } } } } else if (activation != null) { for (int i = 0; i < y.Length; i++) { y[i] = activation.ForwardActivate(y[i]); } } return(NdArray.Convert(y, new[] { outputCount, outputHeight, outputWidth }, x.BatchCount, conv2d)); }
public static void SingleOutputBackward(NdArray <Real> y, NdArray <Real> x, NdArray <Real> weight, NdArray <Real> bias, int strideX, int strideY, int padX, int padY, ICompressibleActivation <Real> activation) { //int outputCount = weight.Shape[0]; int inputCount = weight.Shape[1]; int kernelHeight = weight.Shape[2]; int kernelWidth = weight.Shape[3]; Real[] activatedgy = activation != null?activation.GetActivatedgy(y, x): y.Grad; if (bias != null) { CalcBiasGrad(activatedgy, y.Shape, y.BatchCount, bias.Grad); } for (int batchCounter = 0; batchCounter < y.BatchCount; batchCounter++) { int yBatchOffset = batchCounter * y.Length; int xBatchOffset = batchCounter * x.Length; for (int och = 0; och < y.Shape[0]; och++) { int wOchOffset = och * inputCount * kernelHeight * kernelWidth; int yChOffset = och * y.Shape[1] * y.Shape[2]; for (int oy = 0; oy < y.Shape[1] * strideY; oy += strideY) { int iyStart = oy - padY < 0 ? 0 : oy - padY; int iyLimit = kernelHeight + oy - padY < x.Shape[1] ? kernelHeight + oy - padY : x.Shape[1]; for (int ox = 0; ox < y.Shape[2] * strideX; ox += strideX) { int ixStart = ox - padX < 0 ? 0 : ox - padX; int ixLimit = kernelWidth + ox - padX < x.Shape[2] ? kernelWidth + ox - padX : x.Shape[2]; int gyIndex = yBatchOffset + yChOffset + oy / strideY * y.Shape[2] + ox / strideX; for (int ich = 0; ich < x.Shape[0]; ich++) { int wIchOffset = wOchOffset + ich * kernelHeight * kernelWidth; int xChOffset = xBatchOffset + ich * x.Shape[1] * x.Shape[2]; for (int iy = iyStart; iy < iyLimit; iy++) { for (int ix = ixStart; ix < ixLimit; ix++) { int wIndex = wIchOffset + (iy - oy + padY) * kernelWidth + ix - ox + padX; int xIndex = xChOffset + iy * x.Shape[2] + ix; weight.Grad[wIndex] += x.Data[xIndex] * activatedgy[gyIndex]; x.Grad[xIndex] += weight.Data[wIndex] * activatedgy[gyIndex]; } } } } } } } }
public Deconvolution2D(int inputChannels, int outputChannels, int[] kSize, int[] subSample = null, int[] trim = null, bool noBias = false, Array initialW = null, Array initialb = null, ICompressibleActivation activation = null, string name = "Deconvolution2D", string[] inputNames = null, string[] outputNames = null, bool gpuEnable = false) : base(inputChannels, outputChannels, kSize, subSample, trim, noBias, initialW, initialb, activation, name, inputNames, outputNames) { this.SetParallel(gpuEnable); }
public Deconvolution2D(int inputChannels, int outputChannels, int kernelSize, int stride = 1, int pad = 0, bool noBias = false, Array initialW = null, Array initialb = null, ICompressibleActivation activation = null, string name = "Deconvolution2D", string[] inputNames = null, string[] outputNames = null, bool gpuEnable = false) : base(inputChannels, outputChannels, kernelSize, stride, pad, noBias, initialW, initialb, activation, name, inputNames, outputNames) { this.SetParallel(gpuEnable); }
public MaskedLinear(int inputCount, int outputCount, bool noBias = false, Array initialW = null, Array initialb = null, Action <NdArray <T> > weightInitializer = null, ICompressibleActivation <T> activation = null, string name = FUNCTION_NAME, string[] inputNames = null, string[] outputNames = null) : base(inputCount, outputCount, noBias, initialW, initialb, weightInitializer, activation, name, inputNames, outputNames) { this.Mask = new NdArray <T>(outputCount, inputCount); this.Mask.InitGrad();//Maskは更新されない非パラメータなので自分で初期化する }
public static void SingleOutputBackward(NdArray <Real> y, NdArray <Real> x, NdArray <Real> mask, NdArray <Real> weight, NdArray <Real> bias, ComputeKernel backwardgWKernel, ComputeKernel backwardgXKernel, ICompressibleActivation <Real> activation) { NdArray <Real> maskedWeight = weight * mask; maskedWeight.InitGrad();//MaskedWeightはOptimizerの対象にならない非パラメータの為初期化が必要 SingleOutputBackward(y, x, maskedWeight, bias, backwardgWKernel, backwardgXKernel, activation); for (int i = 0; i < weight.Data.Length; i++) { mask.Grad[i] = maskedWeight.Grad[i]; //マスク前の重みの傾きをマスクの傾きへ退避 weight.Grad[i] += mask.Data[i] * maskedWeight.Grad[i]; //マスクした傾きを適用 } }
public MaskedLinear(int inputCount, int outputCount, bool noBias = false, Array initialW = null, T[] initialb = null, Action <NdArray <T> > weightInitializer = null, ICompressibleActivation <T> activation = null, string name = "Linear", string[] inputNames = null, string[] outputNames = null, bool gpuEnable = false) : base(inputCount, outputCount, noBias, initialW, initialb, weightInitializer, activation, name, inputNames, outputNames, gpuEnable) { this.Mask = new NdArray <T>(outputCount, inputCount); this.Mask.InitGrad();//Maskは更新されない非パラメータなので自分で初期化する this.InitMaskedFunc(new StreamingContext()); }
public static NdArray <Real> SingleInputForward(NdArray <Real> x, NdArray <Real> mask, NdArray <Real> weight, NdArray <Real> bias, ICompressibleActivation <Real> activation, IFunction <Real> linear) { return(SingleInputForward(x, weight * mask, bias, activation, linear)); }