public static void Run()
{
//目標とするフィルタを作成（実践であればココは不明な値となる）
Deconvolution2D decon_core = new Deconvolution2D(1, 1, 15, 1, 7, gpuEnable: true)
{
Weight = { Data = MakeOneCore() }
};
Deconvolution2D model = new Deconvolution2D(1, 1, 15, 1, 7, gpuEnable: true);
SGD optimizer = new SGD(learningRate: 0.00005); //大きいと発散する
model.SetOptimizer(optimizer);
MeanSquaredError meanSquaredError = new MeanSquaredError();
//移植元では同じ教育画像で教育しているが、より実践に近い学習に変更
for (int i = 0; i < 11; i++)
{
//ランダムに点が打たれた画像を生成
NdArray img_p = getRandomImage();
//目標とするフィルタで学習用の画像を出力
NdArray[] img_core = decon_core.Forward(img_p);
//未学習のフィルタで画像を出力
NdArray[] img_y = model.Forward(img_p);
Real loss = meanSquaredError.Evaluate(img_y, img_core);
model.Backward(img_y);
model.Update();
Console.WriteLine("epoch" + i + " : " + loss);
}
}
public static void Run()
{
//Create a target filter (If it is practical, here is an unknown value)
Deconvolution2D decon_core = new Deconvolution2D(1, 1, 15, 1, 7, gpuEnable: true)
{
Weight = { Data = MakeOneCore() }
};
Deconvolution2D model = new Deconvolution2D(1, 1, 15, 1, 7, gpuEnable: true);
SGD optimizer = new SGD(learningRate: 0.00005); //When it is big, it diverges.
model.SetOptimizer(optimizer);
MeanSquaredError meanSquaredError = new MeanSquaredError();
//At the transplant source, we are educating with the same educational image, but changing to learning closer to practice
for (int i = 0; i < 11; i++)
{
//Generate random dotted images
NdArray img_p = getRandomImage();
//Output a learning image with a target filter
NdArray[] img_core = decon_core.Forward(img_p);
//Output an image with an unlearned filter
NdArray[] img_y = model.Forward(img_p);
Real loss = meanSquaredError.Evaluate(img_y, img_core);
model.Backward(img_y);
model.Update();
Console.WriteLine("epoch" + i + " : " + loss);
}
}
public static void Run()
{
// Create a target filter (In case of practice, here is the unknown value)
Deconvolution2D decon_core = new Deconvolution2D(true, 1, 1, 15, 1, 7, gpuEnable: true)
{
Weight = { Data = MakeOneCore() }
};
Deconvolution2D model = new Deconvolution2D(true, 1, 1, 15, 1, 7, gpuEnable: true);
SGD optimizer = new SGD(learningRate: 0.00005); // diverge if big
model.SetOptimizer(optimizer);
MeanSquaredError meanSquaredError = new MeanSquaredError();
// I am educating with the same educational image at the transplanting source, but changing to learning closer to practice
for (int i = 0; i < 11; i++)
{
// Generate an image with randomly struck points
NdArray img_p = getRandomImage();
// Output a learning image with a target filter
NdArray[] img_core = decon_core.Forward(true, img_p);
// Output an image with an unlearned filter
NdArray[] img_y = model.Forward(true, img_p);
Real loss = meanSquaredError.Evaluate(img_y, img_core);
model.Backward(true, img_y);
model.Update();
RILogManager.Default?.SendDebug("epoch" + i + " : " + loss);
}
}
public static void Run()
{
sw = new Stopwatch();
Console.WriteLine("Generating Test Data...");
NdArray input = new NdArray(BenchDataMaker.GetRealArray(INPUT_SIZE));
NdArray inputImage = new NdArray(BenchDataMaker.GetRealArray(3 * 256 * 256 * 5), new[] { 3, 256, 256 }, 5);
Console.WriteLine("Generated Test Data");
Console.WriteLine("Init Linear");
Linear linear = new Linear(INPUT_SIZE, OUTPUT_SIZE);
Console.WriteLine("Init Tanh");
Tanh tanh = new Tanh();
Console.WriteLine("Init Sigmoid");
Sigmoid sigmoid = new Sigmoid();
Console.WriteLine("Init ReLU");
ReLU relu = new ReLU();
Console.WriteLine("Init LeakyReLU");
LeakyReLU leakyRelu = new LeakyReLU();
Console.WriteLine("Init MaxPooling");
MaxPooling maxPooling = new MaxPooling(2);
Console.WriteLine("Init Convolution2D");
Convolution2D conv2d = new Convolution2D(3, 32, 3);
Console.WriteLine("Init Deconvolution2D");
Deconvolution2D deconv2d = new Deconvolution2D(32, 3, 3);
Dropout dropout = new Dropout();
TestLayer(linear, input);
Console.WriteLine("aaaaaaaaaaaa");
Console.ReadLine();
TestLayer(tanh, input);
TestLayer(sigmoid, input);
TestLayer(relu, input);
TestLayer(leakyRelu, input);
TestLayer(maxPooling, inputImage);
TestLayer(conv2d, inputImage);
TestLayer(deconv2d, inputImage);
TestLayer(dropout, input);
}
public Sample13WinForm()
{
this.InitializeComponent();
ClientSize = new Size(128 * 4, 128 * 4);
//目標とするフィルタを作成（実践であればココは不明な値となる）
this.decon_core = new Deconvolution2D(1, 1, 15, 1, 7, gpuEnable: true)
{
Weight = { Data = MakeOneCore() }
};
this.model = new Deconvolution2D(1, 1, 15, 1, 7, gpuEnable: true);
this.optimizer = new SGD(learningRate: 0.01); //大きいと発散する
this.model.SetOptimizer(this.optimizer);
}
public Test13WinForm()
{
this.InitializeComponent();
ClientSize = new Size(128 * 4, 128 * 4);
//Create a target filter (If it is practical, here is an unknown value)
this.decon_core = new Deconvolution2D(1, 1, 15, 1, 7, gpuEnable: true)
{
Weight = { Data = MakeOneCore() }
};
this.model = new Deconvolution2D(1, 1, 15, 1, 7, gpuEnable: true);
this.optimizer = new SGD(learningRate: 0.01); //When it is big, it diverges.
this.model.SetOptimizer(this.optimizer);
}
public Test13WinForm()
{
InitializeComponent();
ClientSize = new Size(128 * 4, 128 * 4);
// Create a target filter (In case of practice, here is the unknown value)
decon_core = new Deconvolution2D(true, 1, 1, 15, 1, 7, gpuEnable: true)
{
Weight = { Data = MakeOneCore() }
};
model = new Deconvolution2D(true, 1, 1, 15, 1, 7, gpuEnable: true);
optimizer = new SGD(learningRate: 0.01); // diverge if big
model.SetOptimizer(optimizer);
}
public void ExecuteTest()
{
int inchannels = 4, outchannels = 6, inwidth = 13, inheight = 17, kwidth = 3, kheight = 5, stride = 2, batch = 7;
VariableField x = new Tensor(Shape.Map2D(inchannels, inwidth, inheight, batch));
Layer layer = new Deconvolution2D(inchannels, outchannels, kwidth, kheight, stride, use_bias: true, pad_mode: PaddingMode.Edge, "conv");
Field y = layer.Forward(x);
(Flow flow, Parameters parameters) = Flow.Optimize(y);
flow.Execute();
Assert.AreEqual(2, parameters.Count);
Assert.AreEqual(inchannels, layer.InChannels);
Assert.AreEqual(outchannels, layer.OutChannels);
Assert.AreEqual(kwidth, layer.Width);
Assert.AreEqual(kheight, layer.Height);
}
public static void Run()
{
Stopwatch sw = new Stopwatch();
NdArray inputArrayCpu = new NdArray(Initializer.GetRealArray(INPUT_SIZE));
NdArray inputArrayGpu = new NdArray(Initializer.GetRealArray(INPUT_SIZE));
//Linear
Linear linear = new Linear(INPUT_SIZE, OUTPUT_SIZE);
Console.WriteLine("◆" + linear.Name);
sw.Restart();
NdArray[] gradArrayCpu = linear.Forward(inputArrayCpu);
sw.Stop();
Console.WriteLine("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data; //DataをGradとして使用
sw.Restart();
linear.Backward(gradArrayCpu);
sw.Stop();
Console.WriteLine("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (linear.SetGpuEnable(true))
{
sw.Restart();
NdArray[] gradArrayGpu = linear.Forward(inputArrayGpu);
sw.Stop();
Console.WriteLine("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayGpu[0].Grad = gradArrayGpu[0].Data;
sw.Restart();
linear.Backward(gradArrayGpu);
sw.Stop();
Console.WriteLine("Backward[Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
}
//Tanh
TanhActivation tanh = new TanhActivation();
Console.WriteLine("\n◆" + tanh.Name);
sw.Restart();
gradArrayCpu = tanh.Forward(inputArrayCpu);
sw.Stop();
Console.WriteLine("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
tanh.Backward(gradArrayCpu);
sw.Stop();
Console.WriteLine("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (tanh.SetGpuEnable(true))
{
sw.Restart();
NdArray[] gradArrayGpu = tanh.Forward(inputArrayGpu);
sw.Stop();
Console.WriteLine("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayGpu[0].Grad = gradArrayGpu[0].Data;
sw.Restart();
tanh.Backward(gradArrayGpu);
sw.Stop();
Console.WriteLine("Backward[Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
}
//Sigmoid
Sigmoid sigmoid = new Sigmoid();
Console.WriteLine("\n◆" + sigmoid.Name);
sw.Restart();
gradArrayCpu = sigmoid.Forward(inputArrayCpu);
sw.Stop();
Console.WriteLine("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
sigmoid.Backward(gradArrayCpu);
sw.Stop();
Console.WriteLine("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (sigmoid.SetGpuEnable(true))
{
sw.Restart();
NdArray[] gradArrayGpu = sigmoid.Forward(inputArrayGpu);
sw.Stop();
Console.WriteLine("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayGpu[0].Grad = gradArrayGpu[0].Data;
sw.Restart();
sigmoid.Backward(gradArrayGpu);
sw.Stop();
Console.WriteLine("Backward[Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
}
//ReLU
ReLU relu = new ReLU();
Console.WriteLine("\n◆" + relu.Name);
sw.Restart();
gradArrayCpu = relu.Forward(inputArrayCpu);
sw.Stop();
Console.WriteLine("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
relu.Backward(gradArrayCpu);
sw.Stop();
Console.WriteLine("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (relu.SetGpuEnable(true))
{
sw.Restart();
NdArray[] gradArrayGpu = relu.Forward(inputArrayGpu);
sw.Stop();
Console.WriteLine("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayGpu[0].Grad = gradArrayGpu[0].Data;
sw.Restart();
relu.Backward(gradArrayGpu);
sw.Stop();
Console.WriteLine("Backward[Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
}
//LeakyReLU
LeakyReLU leakyRelu = new LeakyReLU();
Console.WriteLine("\n◆" + leakyRelu.Name);
sw.Restart();
gradArrayCpu = leakyRelu.Forward(inputArrayCpu);
sw.Stop();
Console.WriteLine("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
leakyRelu.Backward(gradArrayCpu);
sw.Stop();
Console.WriteLine("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (leakyRelu.SetGpuEnable(true))
{
sw.Restart();
NdArray[] gradArrayGpu = leakyRelu.Forward(inputArrayGpu);
sw.Stop();
Console.WriteLine("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayGpu[0].Grad = gradArrayGpu[0].Data;
sw.Restart();
leakyRelu.Backward(gradArrayGpu);
sw.Stop();
Console.WriteLine("Backward[Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
}
NdArray inputImageArrayGpu = new NdArray(Initializer.GetRealArray(3 * 256 * 256 * 5), new[] { 3, 256, 256 }, 5);
NdArray inputImageArrayCpu = new NdArray(Initializer.GetRealArray(3 * 256 * 256 * 5), new[] { 3, 256, 256 }, 5);
//MaxPooling
MaxPooling2D maxPooling2D = new MaxPooling2D(3);
Console.WriteLine("\n◆" + maxPooling2D.Name);
sw.Restart();
NdArray[] gradImageArrayCpu = maxPooling2D.Forward(inputImageArrayCpu);
sw.Stop();
Console.WriteLine("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradImageArrayCpu[0].Grad = gradImageArrayCpu[0].Data;
sw.Restart();
maxPooling2D.Backward(gradImageArrayCpu);
sw.Stop();
Console.WriteLine("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (maxPooling2D.SetGpuEnable(true))
{
sw.Restart();
maxPooling2D.Forward(inputImageArrayGpu);
sw.Stop();
Console.WriteLine("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
//メモリ転送のみのため実装がない
Console.WriteLine("Backward[Gpu] : None");
}
//Conv2D
Convolution2D conv2d = new Convolution2D(3, 3, 3);
Console.WriteLine("\n◆" + conv2d.Name);
sw.Restart();
gradImageArrayCpu = conv2d.Forward(inputImageArrayCpu);
sw.Stop();
Console.WriteLine("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradImageArrayCpu[0].Grad = gradImageArrayCpu[0].Data;
sw.Restart();
conv2d.Backward(gradImageArrayCpu);
sw.Stop();
Console.WriteLine("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (conv2d.SetGpuEnable(true))
{
sw.Restart();
NdArray[] gradImageArrayGpu = conv2d.Forward(inputImageArrayGpu);
sw.Stop();
Console.WriteLine("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradImageArrayGpu[0].Grad = gradImageArrayGpu[0].Data;
sw.Restart();
conv2d.Backward(gradImageArrayGpu);
sw.Stop();
Console.WriteLine("Backward[Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
}
//Deconv2D
Deconvolution2D deconv2d = new Deconvolution2D(3, 3, 3);
Console.WriteLine("\n◆" + deconv2d.Name);
sw.Restart();
gradImageArrayCpu = deconv2d.Forward(inputImageArrayCpu);
sw.Stop();
Console.WriteLine("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradImageArrayCpu[0].Grad = gradImageArrayCpu[0].Data;
sw.Restart();
deconv2d.Backward(gradImageArrayCpu);
sw.Stop();
Console.WriteLine("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (deconv2d.SetGpuEnable(true))
{
sw.Restart();
NdArray[] gradImageArrayGpu = deconv2d.Forward(inputImageArrayGpu);
sw.Stop();
Console.WriteLine("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradImageArrayGpu[0].Grad = gradImageArrayGpu[0].Data;
sw.Restart();
deconv2d.Backward(gradImageArrayGpu);
sw.Stop();
Console.WriteLine("Backward[Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
}
//Dropout
Dropout dropout = new Dropout();
Console.WriteLine("\n◆" + dropout.Name);
sw.Restart();
gradArrayCpu = dropout.Forward(inputArrayCpu);
sw.Stop();
Console.WriteLine("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
dropout.Backward(gradArrayCpu);
sw.Stop();
Console.WriteLine("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (dropout.SetGpuEnable(true))
{
sw.Restart();
NdArray[] gradArrayGpu = dropout.Forward(inputArrayGpu);
sw.Stop();
Console.WriteLine("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayGpu[0].Grad = gradArrayGpu[0].Data;
sw.Restart();
dropout.Backward(gradArrayGpu);
sw.Stop();
Console.WriteLine("Backward[Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Sets the parameters. </summary>
///
/// <param name="func"> The function. </param>
/// <param name="modelData"> Information describing the model. </param>
////////////////////////////////////////////////////////////////////////////////////////////////////
static void SetParams(Function func, NpzDictionary modelData)
{
if (func is Linear)
{
Linear linear = (Linear)func;
Array.Copy(Real.GetArray(modelData[func.Name + "/W.npy"]), linear.Weight.Data, linear.Weight.Data.Length);
if (!linear.NoBias)
{
Array.Copy(Real.GetArray(modelData[func.Name + "/b.npy"]), linear.Bias.Data, linear.Bias.Data.Length);
}
}
else if (func is Convolution2D)
{
Convolution2D conv2D = (Convolution2D)func;
Array.Copy(Real.GetArray(modelData[func.Name + "/W.npy"]), conv2D.Weight.Data, conv2D.Weight.Data.Length);
if (!conv2D.NoBias)
{
Array.Copy(Real.GetArray(modelData[func.Name + "/b.npy"]), conv2D.Bias.Data, conv2D.Bias.Data.Length);
}
}
else if (func is Deconvolution2D)
{
Deconvolution2D deconv2D = (Deconvolution2D)func;
Array.Copy(Real.GetArray(modelData[func.Name + "/W.npy"]), deconv2D.Weight.Data, deconv2D.Weight.Data.Length);
if (!deconv2D.NoBias)
{
Array.Copy(Real.GetArray(modelData[func.Name + "/b.npy"]), deconv2D.Bias.Data, deconv2D.Bias.Data.Length);
}
}
else if (func is EmbedID)
{
EmbedID embed = (EmbedID)func;
Array.Copy(Real.GetArray(modelData[func.Name + "/W.npy"]), embed.Weight.Data, embed.Weight.Data.Length);
}
else if (func is BatchNormalization)
{
BatchNormalization bn = (BatchNormalization)func;
Array.Copy(Real.GetArray(modelData[func.Name + "/beta.npy"]), bn.Beta.Data, bn.Beta.Data.Length);
Array.Copy(Real.GetArray(modelData[func.Name + "/gamma.npy"]), bn.Gamma.Data, bn.Gamma.Data.Length);
if (bn.IsTrain)
{
if (modelData.ContainsKey(func.Name + "/avg_mean.npy"))
{
Array.Copy(Real.GetArray(modelData[func.Name + "/avg_mean.npy"]), bn.AvgMean.Data, bn.AvgMean.Data.Length);
}
if (modelData.ContainsKey(func.Name + "/avg_var.npy"))
{
Array.Copy(Real.GetArray(modelData[func.Name + "/avg_var.npy"]), bn.AvgVar.Data, bn.AvgVar.Data.Length);
}
}
}
else if (func is MultiplyScale)
{
MultiplyScale scale = (MultiplyScale)func;
Array.Copy(Real.GetArray(modelData[func.Name + "/W.npy"]), scale.Weight.Data, scale.Weight.Data.Length);
if (scale.BiasTerm)
{
Array.Copy(Real.GetArray(modelData[func.Name + "/bias/b.npy"]), scale.Bias.Data, scale.Bias.Data.Length);
}
}
}
static void SetParams <T>(Function <T> func, NpzDictionary modelData) where T : unmanaged, IComparable <T>
{
if (func is Linear <T> )
{
Linear <T> linear = (Linear <T>)func;
linear.Weight.Data = modelData[func.Name + "/W.npy"].FlattenEx <T>();
if (linear.Bias != null)
{
linear.Bias.Data = modelData[func.Name + "/b.npy"].FlattenEx <T>();
}
}
else if (func is Convolution2D <T> )
{
Convolution2D <T> conv2D = (Convolution2D <T>)func;
conv2D.Weight.Data = modelData[func.Name + "/W.npy"].FlattenEx <T>();
if (conv2D.Bias != null)
{
conv2D.Bias.Data = modelData[func.Name + "/b.npy"].FlattenEx <T>();
}
}
else if (func is Deconvolution2D <T> )
{
Deconvolution2D <T> deconv2D = (Deconvolution2D <T>)func;
deconv2D.Weight.Data = modelData[func.Name + "/W.npy"].FlattenEx <T>();
if (deconv2D.Bias != null)
{
deconv2D.Bias.Data = modelData[func.Name + "/b.npy"].FlattenEx <T>();
}
}
else if (func is EmbedID <T> )
{
EmbedID <T> embed = (EmbedID <T>)func;
embed.Weight.Data = modelData[func.Name + "/W.npy"].FlattenEx <T>();
}
else if (func is BatchNormalization <T> )
{
BatchNormalization <T> bn = (BatchNormalization <T>)func;
bn.Beta.Data = modelData[func.Name + "/beta.npy"].FlattenEx <T>();
bn.Gamma.Data = modelData[func.Name + "/gamma.npy"].FlattenEx <T>();
if (bn.Train)
{
if (modelData.ContainsKey(func.Name + "/avg_mean.npy"))
{
bn.AvgMean.Data = modelData[func.Name + "/avg_mean.npy"].FlattenEx <T>();
}
if (modelData.ContainsKey(func.Name + "/avg_var.npy"))
{
bn.AvgVar.Data = modelData[func.Name + "/avg_var.npy"].FlattenEx <T>();
}
}
}
else if (func is MultiplyScale <T> )
{
MultiplyScale <T> scale = (MultiplyScale <T>)func;
scale.Weight.Data = modelData[func.Name + "/W.npy"].FlattenEx <T>();
if (scale.BiasTerm)
{
scale.Bias.Data = modelData[func.Name + "/bias/b.npy"].FlattenEx <T>();
}
}
else if (func is LSTM <T> )
{
LSTM <T> lstm = (LSTM <T>)func;
lstm.lateral.Weight.Data = modelData[func.Name + "/lateral/W.npy"].FlattenEx <T>();
lstm.upward.Weight.Data = modelData[func.Name + "/upward/W.npy"].FlattenEx <T>();
lstm.upward.Bias.Data = modelData[func.Name + "/upward/b.npy"].FlattenEx <T>();
}
}
public static void Run(bool verbose)
{
Stopwatch sw = new Stopwatch();
NdArray inputArrayCpu = new NdArray(BenchDataMaker.GetRealArray(INPUT_SIZE));
NdArray inputArrayGpu = new NdArray(BenchDataMaker.GetRealArray(INPUT_SIZE));
Ensure.Argument(inputArrayGpu).NotNull();
Ensure.Argument(inputArrayCpu).NotNull();
//Linear
Linear linear = new Linear(verbose, INPUT_SIZE, OUTPUT_SIZE);
if (verbose)
{
RILogManager.Default?.EnterMethod(linear.Name);
}
sw.Restart();
NdArray[] gradArrayCpu = linear.Forward(verbose, inputArrayCpu);
sw.Stop();
if (verbose)
{
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
}
Ensure.Argument(gradArrayCpu).NotNull();
gradArrayCpu[0].Grad = gradArrayCpu[0].Data; // Use Data as Grad
sw.Restart();
linear.Backward(verbose, gradArrayCpu);
sw.Stop();
if (verbose)
{
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
}
if (linear.SetGpuEnable(true))
{
sw.Restart();
NdArray[] gradArrayGpu = linear.Forward(verbose, inputArrayGpu);
sw.Stop();
if (verbose)
{
RILogManager.Default?.SendDebug("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
}
gradArrayGpu[0].Grad = gradArrayGpu[0].Data;
sw.Restart();
linear.Backward(verbose, gradArrayGpu);
sw.Stop();
if (verbose)
{
RILogManager.Default?.SendDebug("Backward[Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
}
}
if (verbose)
{
RILogManager.Default?.ExitMethod(linear.Name);
}
//Tanh
Tanh tanh = new Tanh();
if (verbose)
{
RILogManager.Default?.EnterMethod(tanh.Name);
}
sw.Restart();
gradArrayCpu = tanh.Forward(verbose, inputArrayCpu);
sw.Stop();
if (verbose)
{
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
}
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
tanh.Backward(verbose, gradArrayCpu);
sw.Stop();
if (verbose)
{
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
}
if (tanh.SetGpuEnable(true))
{
HandleGPU(verbose, sw, tanh, inputArrayGpu);
}
if (verbose)
{
RILogManager.Default?.ExitMethod(tanh.Name);
}
//Sigmoid
Sigmoid sigmoid = new Sigmoid();
if (verbose)
{
RILogManager.Default?.EnterMethod(sigmoid.Name);
}
sw.Restart();
gradArrayCpu = sigmoid.Forward(verbose, inputArrayCpu);
sw.Stop();
if (verbose)
{
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
}
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
sigmoid.Backward(verbose, gradArrayCpu);
sw.Stop();
if (verbose)
{
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
}
if (sigmoid.SetGpuEnable(true))
{
HandleGPU(verbose, sw, sigmoid, inputArrayGpu);
}
if (verbose)
{
RILogManager.Default?.ExitMethod(tanh.Name);
}
//Softmax
Softmax sm = new Softmax();
RILogManager.Default?.EnterMethod(sm.Name);
sw.Restart();
gradArrayCpu = sm.Forward(verbose, inputArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
sm.Backward(verbose, gradArrayCpu);
sw.Stop();
if (verbose)
{
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
}
if (verbose)
{
RILogManager.Default?.ExitMethod(sm.Name);
}
//Softplus
Softplus sp = new Softplus();
if (verbose)
{
RILogManager.Default?.EnterMethod(sp.Name);
}
sw.Restart();
gradArrayCpu = sp.Forward(verbose, inputArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
sp.Backward(verbose, gradArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
RILogManager.Default?.ExitMethod(sp.Name);
//ReLU
ReLU relu = new ReLU();
RILogManager.Default?.EnterMethod(relu.Name);
sw.Restart();
gradArrayCpu = relu.Forward(verbose, inputArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
relu.Backward(verbose, gradArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (relu.SetGpuEnable(true))
{
HandleGPU(verbose, sw, relu, inputArrayGpu);
}
RILogManager.Default?.ExitMethod(relu.Name);
//LeakyReLU
LeakyReLU leakyRelu = new LeakyReLU();
RILogManager.Default?.EnterMethod(leakyRelu.Name);
sw.Restart();
gradArrayCpu = leakyRelu.Forward(verbose, inputArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
leakyRelu.Backward(verbose, gradArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (leakyRelu.SetGpuEnable(true))
{
HandleGPU(verbose, sw, leakyRelu, inputArrayGpu);
}
RILogManager.Default?.ExitMethod(leakyRelu.Name);
//ReLuTanh
ReLuTanh rth = new ReLuTanh();
RILogManager.Default?.EnterMethod(rth.Name);
sw.Restart();
gradArrayCpu = rth.Forward(verbose, inputArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
rth.Backward(verbose, gradArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (rth.SetGpuEnable(true))
{
HandleGPU(verbose, sw, rth, inputArrayGpu);
}
RILogManager.Default?.ExitMethod(rth.Name);
////Swish
//Swish swi = new Swish();
//RILogManager.Default?.SendDebug(swi.Name);
//sw.Restart();
//gradArrayCpu = swi.Forward(inputArrayCpu);
//sw.Stop();
//RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
//gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
//sw.Restart();
//swi.Backward(gradArrayCpu);
//sw.Stop();
//RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
NdArray inputImageArrayGpu = new NdArray(BenchDataMaker.GetRealArray(3 * 256 * 256 * 5), new[] { 3, 256, 256 }, 5);
NdArray inputImageArrayCpu = new NdArray(BenchDataMaker.GetRealArray(3 * 256 * 256 * 5), new[] { 3, 256, 256 }, 5);
//MaxPooling
MaxPooling maxPooling = new MaxPooling(3);
RILogManager.Default?.EnterMethod(maxPooling.Name);
sw.Restart();
NdArray[] gradImageArrayCpu = maxPooling.Forward(verbose, inputImageArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradImageArrayCpu[0].Grad = gradImageArrayCpu[0].Data;
sw.Restart();
maxPooling.Backward(verbose, gradImageArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (maxPooling.SetGpuEnable(true))
{
sw.Restart();
maxPooling.Forward(verbose, inputImageArrayGpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
// There is no implementation for memory transfer only
RILogManager.Default?.SendDebug("Backward[Gpu] : None");
}
RILogManager.Default?.ExitMethod(maxPooling.Name);
//AvgPooling
AveragePooling avgPooling = new AveragePooling(3);
RILogManager.Default?.EnterMethod(avgPooling.Name);
sw.Restart();
gradImageArrayCpu = avgPooling.Forward(verbose, inputImageArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradImageArrayCpu[0].Grad = gradImageArrayCpu[0].Data;
sw.Restart();
avgPooling.Backward(verbose, gradImageArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
RILogManager.Default?.ExitMethod(avgPooling.Name);
//Conv2D
Convolution2D conv2d = new Convolution2D(verbose, 3, 3, 3);
RILogManager.Default?.EnterMethod(conv2d.Name);
sw.Restart();
gradImageArrayCpu = conv2d.Forward(verbose, inputImageArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradImageArrayCpu[0].Grad = gradImageArrayCpu[0].Data;
sw.Restart();
conv2d.Backward(verbose, gradImageArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (conv2d.SetGpuEnable(true))
{
HandleGPU(verbose, sw, conv2d, inputArrayGpu);
}
RILogManager.Default?.ExitMethod(conv2d.Name);
//Deconv2D
Deconvolution2D deconv2d = new Deconvolution2D(verbose, 3, 3, 3);
RILogManager.Default?.EnterMethod(deconv2d.Name);
sw.Restart();
gradImageArrayCpu = deconv2d.Forward(verbose, inputImageArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradImageArrayCpu[0].Grad = gradImageArrayCpu[0].Data;
sw.Restart();
deconv2d.Backward(verbose, gradImageArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (deconv2d.SetGpuEnable(true))
{
HandleGPU(verbose, sw, deconv2d, inputArrayGpu);
}
RILogManager.Default?.ExitMethod(deconv2d.Name);
//Dropout
Dropout dropout = new Dropout();
RILogManager.Default?.EnterMethod(dropout.Name);
sw.Restart();
gradArrayCpu = dropout.Forward(verbose, inputArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
dropout.Backward(verbose, gradArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (dropout.SetGpuEnable(true))
{
sw.Restart();
NdArray[] gradArrayGpu = dropout.Forward(verbose, inputArrayGpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayGpu[0].Grad = gradArrayGpu[0].Data;
sw.Restart();
dropout.Backward(verbose, gradArrayGpu);
sw.Stop();
RILogManager.Default?.SendDebug("Backward[Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
}
RILogManager.Default?.ExitMethod(dropout.Name);
//ArcSinH
ArcSinH a = new ArcSinH();
RILogManager.Default?.EnterMethod(a.Name);
sw.Restart();
gradArrayCpu = a.Forward(verbose, inputArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
a.Backward(verbose, gradArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (a.SetGpuEnable(true))
{
HandleGPU(verbose, sw, a, inputArrayGpu);
}
RILogManager.Default?.ExitMethod(a.Name);
//ELU
ELU e = new ELU();
RILogManager.Default?.EnterMethod(e.Name);
sw.Restart();
gradArrayCpu = e.Forward(verbose, inputArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
e.Backward(verbose, gradArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
RILogManager.Default?.ExitMethod(e.Name);
//LeakyReluShifted
LeakyReLUShifted lrs = new LeakyReLUShifted();
RILogManager.Default?.EnterMethod(lrs.Name);
sw.Restart();
gradArrayCpu = lrs.Forward(verbose, inputArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
lrs.Backward(verbose, gradArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (lrs.SetGpuEnable(true))
{
HandleGPU(verbose, sw, lrs, inputArrayGpu);
}
RILogManager.Default?.ExitMethod(lrs.Name);
//Logistic
LogisticFunction lf = new LogisticFunction();
RILogManager.Default?.EnterMethod(lf.Name);
sw.Restart();
gradArrayCpu = lf.Forward(verbose, inputArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
lf.Backward(verbose, gradArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (lf.SetGpuEnable(true))
{
HandleGPU(verbose, sw, lf, inputArrayGpu);
}
RILogManager.Default?.ExitMethod(lf.Name);
//MaxMinusOne
MaxMinusOne mmo = new MaxMinusOne();
RILogManager.Default?.EnterMethod(mmo.Name);
sw.Restart();
gradArrayCpu = mmo.Forward(verbose, inputArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
mmo.Backward(verbose, gradArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (mmo.SetGpuEnable(true))
{
HandleGPU(verbose, sw, mmo, inputArrayGpu);
}
RILogManager.Default?.ExitMethod(mmo.Name);
//ScaledELU
ScaledELU se = new ScaledELU();
RILogManager.Default?.EnterMethod(se.Name);
sw.Restart();
gradArrayCpu = se.Forward(verbose, inputArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
se.Backward(verbose, gradArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (se.SetGpuEnable(true))
{
HandleGPU(verbose, sw, se, inputArrayGpu);
}
RILogManager.Default?.ExitMethod(se.Name);
//Sine
Sine s = new Sine();
RILogManager.Default?.EnterMethod(s.Name);
sw.Restart();
gradArrayCpu = s.Forward(verbose, inputArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
s.Backward(verbose, gradArrayCpu);
sw.Stop();
RILogManager.Default?.SendDebug("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μｓ");
if (s.SetGpuEnable(true))
{
HandleGPU(verbose, sw, s, inputArrayGpu);
}
RILogManager.Default?.ExitMethod(s.Name);
}
public static void Run()
{
Stopwatch sw = new Stopwatch();
NdArray inputArrayCpu = new NdArray(BenchDataMaker.GetRealArray(INPUT_SIZE));
NdArray inputArrayGpu = new NdArray(BenchDataMaker.GetRealArray(INPUT_SIZE));
NdArray[] gradArrayCpu = null;
//Linear
Linear linear = new Linear(INPUT_SIZE, OUTPUT_SIZE);
Console.WriteLine("◆" + linear.Name);
if (TestCpu)
{
sw.Restart();
gradArrayCpu = linear.Forward(inputArrayCpu);
sw.Stop();
Console.WriteLine("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data; //Use Data as Grad
sw.Restart();
linear.Backward(gradArrayCpu);
sw.Stop();
Console.WriteLine("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
}
if (linear.SetGpuEnable(true))
{
NdArray[] gradArrayGpu = null;
while (true)
{
sw.Restart();
gradArrayGpu = linear.Forward(inputArrayGpu);
sw.Stop();
Console.WriteLine("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
}
gradArrayGpu[0].Grad = gradArrayGpu[0].Data;
sw.Restart();
linear.Backward(gradArrayGpu);
sw.Stop();
Console.WriteLine("Backward[Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
}
//Tanh
Tanh tanh = new Tanh();
Console.WriteLine("\n ◆" + tanh.Name);
sw.Restart();
gradArrayCpu = tanh.Forward(inputArrayCpu);
sw.Stop();
Console.WriteLine("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
tanh.Backward(gradArrayCpu);
sw.Stop();
Console.WriteLine("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
if (tanh.SetGpuEnable(true))
{
sw.Restart();
NdArray[] gradArrayGpu = tanh.Forward(inputArrayGpu);
sw.Stop();
Console.WriteLine("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
gradArrayGpu[0].Grad = gradArrayGpu[0].Data;
sw.Restart();
tanh.Backward(gradArrayGpu);
sw.Stop();
Console.WriteLine("Backward[Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
}
//Sigmoid
Sigmoid sigmoid = new Sigmoid();
Console.WriteLine("\n ◆" + sigmoid.Name);
sw.Restart();
gradArrayCpu = sigmoid.Forward(inputArrayCpu);
sw.Stop();
Console.WriteLine("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
sigmoid.Backward(gradArrayCpu);
sw.Stop();
Console.WriteLine("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
if (sigmoid.SetGpuEnable(true))
{
sw.Restart();
NdArray[] gradArrayGpu = sigmoid.Forward(inputArrayGpu);
sw.Stop();
Console.WriteLine("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
gradArrayGpu[0].Grad = gradArrayGpu[0].Data;
sw.Restart();
sigmoid.Backward(gradArrayGpu);
sw.Stop();
Console.WriteLine("Backward[Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
}
//ReLU
ReLU relu = new ReLU();
Console.WriteLine("\n ◆" + relu.Name);
sw.Restart();
gradArrayCpu = relu.Forward(inputArrayCpu);
sw.Stop();
Console.WriteLine("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
relu.Backward(gradArrayCpu);
sw.Stop();
Console.WriteLine("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
if (relu.SetGpuEnable(true))
{
sw.Restart();
NdArray[] gradArrayGpu = relu.Forward(inputArrayGpu);
sw.Stop();
Console.WriteLine("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
gradArrayGpu[0].Grad = gradArrayGpu[0].Data;
sw.Restart();
relu.Backward(gradArrayGpu);
sw.Stop();
Console.WriteLine("Backward[Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
}
//LeakyReLU
LeakyReLU leakyRelu = new LeakyReLU();
Console.WriteLine("\n ◆" + leakyRelu.Name);
sw.Restart();
gradArrayCpu = leakyRelu.Forward(inputArrayCpu);
sw.Stop();
Console.WriteLine("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
leakyRelu.Backward(gradArrayCpu);
sw.Stop();
Console.WriteLine("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
if (leakyRelu.SetGpuEnable(true))
{
sw.Restart();
NdArray[] gradArrayGpu = leakyRelu.Forward(inputArrayGpu);
sw.Stop();
Console.WriteLine("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
gradArrayGpu[0].Grad = gradArrayGpu[0].Data;
sw.Restart();
leakyRelu.Backward(gradArrayGpu);
sw.Stop();
Console.WriteLine("Backward[Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
}
NdArray inputImageArrayGpu = new NdArray(BenchDataMaker.GetRealArray(3 * 256 * 256 * 5), new[] { 3, 256, 256 }, 5);
NdArray inputImageArrayCpu = new NdArray(BenchDataMaker.GetRealArray(3 * 256 * 256 * 5), new[] { 3, 256, 256 }, 5);
//MaxPooling
MaxPooling maxPooling = new MaxPooling(3);
Console.WriteLine("\n ◆" + maxPooling.Name);
sw.Restart();
NdArray[] gradImageArrayCpu = maxPooling.Forward(inputImageArrayCpu);
sw.Stop();
Console.WriteLine("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
gradImageArrayCpu[0].Grad = gradImageArrayCpu[0].Data;
sw.Restart();
maxPooling.Backward(gradImageArrayCpu);
sw.Stop();
Console.WriteLine("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
if (maxPooling.SetGpuEnable(true))
{
sw.Restart();
maxPooling.Forward(inputImageArrayGpu);
sw.Stop();
Console.WriteLine("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
//There is no implementation for memory transfer only
Console.WriteLine("Backward[Gpu] : None");
}
//Conv2D
Convolution2D conv2d = new Convolution2D(3, 3, 3);
Console.WriteLine("\n ◆" + conv2d.Name);
sw.Restart();
gradImageArrayCpu = conv2d.Forward(inputImageArrayCpu);
sw.Stop();
Console.WriteLine("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
gradImageArrayCpu[0].Grad = gradImageArrayCpu[0].Data;
sw.Restart();
conv2d.Backward(gradImageArrayCpu);
sw.Stop();
Console.WriteLine("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
if (conv2d.SetGpuEnable(true))
{
sw.Restart();
NdArray[] gradImageArrayGpu = conv2d.Forward(inputImageArrayGpu);
sw.Stop();
Console.WriteLine("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
gradImageArrayGpu[0].Grad = gradImageArrayGpu[0].Data;
sw.Restart();
conv2d.Backward(gradImageArrayGpu);
sw.Stop();
Console.WriteLine("Backward[Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
}
//Deconv2D
Deconvolution2D deconv2d = new Deconvolution2D(3, 3, 3);
Console.WriteLine("\n ◆" + deconv2d.Name);
sw.Restart();
gradImageArrayCpu = deconv2d.Forward(inputImageArrayCpu);
sw.Stop();
Console.WriteLine("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
gradImageArrayCpu[0].Grad = gradImageArrayCpu[0].Data;
sw.Restart();
deconv2d.Backward(gradImageArrayCpu);
sw.Stop();
Console.WriteLine("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
if (deconv2d.SetGpuEnable(true))
{
sw.Restart();
NdArray[] gradImageArrayGpu = deconv2d.Forward(inputImageArrayGpu);
sw.Stop();
Console.WriteLine("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
gradImageArrayGpu[0].Grad = gradImageArrayGpu[0].Data;
sw.Restart();
deconv2d.Backward(gradImageArrayGpu);
sw.Stop();
Console.WriteLine("Backward[Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
}
//Dropout
Dropout dropout = new Dropout();
Console.WriteLine("\n ◆" + dropout.Name);
sw.Restart();
gradArrayCpu = dropout.Forward(inputArrayCpu);
sw.Stop();
Console.WriteLine("Forward [Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
gradArrayCpu[0].Grad = gradArrayCpu[0].Data;
sw.Restart();
dropout.Backward(gradArrayCpu);
sw.Stop();
Console.WriteLine("Backward[Cpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
if (dropout.SetGpuEnable(true))
{
sw.Restart();
NdArray[] gradArrayGpu = dropout.Forward(inputArrayGpu);
sw.Stop();
Console.WriteLine("Forward [Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
gradArrayGpu[0].Grad = gradArrayGpu[0].Data;
sw.Restart();
dropout.Backward(gradArrayGpu);
sw.Stop();
Console.WriteLine("Backward[Gpu] : " + (sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L))).ToString("n0") + "μs");
}
}