static BatchNormalization SetupBatchnorm(BatchNormParameter param, List <BlobProto> blobs, string name, string[] inputNames, string[] outputNames)
{
double decay = param.MovingAverageFraction;
double eps = param.Eps;
int size = (int)blobs[0].Shape.Dims[0];
float[] avgMean = blobs[0].Datas;
float[] avgVar = blobs[1].Datas;
if (blobs.Count >= 3)
{
float scalingFactor = blobs[2].Datas[0];
for (int i = 0; i < avgMean.Length; i++)
{
avgMean[i] /= scalingFactor;
}
for (int i = 0; i < avgVar.Length; i++)
{
avgVar[i] /= scalingFactor;
}
}
BatchNormalization batchNormalization = new BatchNormalization(size, decay, eps, name: name, inputNames: inputNames, outputNames: outputNames);
batchNormalization.AvgMean.Data = Real.ToRealArray(avgMean);
batchNormalization.AvgVar.Data = Real.ToRealArray(avgVar);
return(batchNormalization);
}
/// <summary>
/// Functional interface for the batch normalization layer.
/// http://arxiv.org/abs/1502.03167
/// </summary>
/// <param name="inputs"></param>
/// <param name="axis"></param>
/// <param name="momentum"></param>
/// <param name="epsilon"></param>
/// <param name="center"></param>
/// <param name="scale"></param>
/// <param name="beta_initializer"></param>
/// <param name="gamma_initializer"></param>
/// <param name="moving_mean_initializer"></param>
/// <param name="moving_variance_initializer"></param>
/// <param name="training"></param>
/// <param name="trainable"></param>
/// <param name="name"></param>
/// <param name="renorm"></param>
/// <param name="renorm_momentum"></param>
/// <returns></returns>
public Tensors batch_normalization(Tensor inputs,
int axis = -1,
float momentum = 0.99f,
float epsilon = 0.001f,
bool center = true,
bool scale = true,
IInitializer beta_initializer = null,
IInitializer gamma_initializer = null,
IInitializer moving_mean_initializer = null,
IInitializer moving_variance_initializer = null,
Tensor training = null,
bool trainable = true,
string name = null,
bool renorm = false,
float renorm_momentum = 0.99f)
{
var layer = new BatchNormalization(new BatchNormalizationArgs
{
Axis = axis,
Momentum = momentum,
Epsilon = epsilon,
Center = center,
Scale = scale,
BetaInitializer = beta_initializer,
GammaInitializer = gamma_initializer,
MovingMeanInitializer = moving_mean_initializer,
MovingVarianceInitializer = moving_variance_initializer,
Renorm = renorm,
RenormMomentum = renorm_momentum,
Trainable = trainable,
Name = name
});
return(layer.Apply(inputs));
}
/// <summary>
/// Functional interface for the batch normalization layer.
/// http://arxiv.org/abs/1502.03167
/// </summary>
/// <param name="inputs"></param>
/// <param name="axis"></param>
/// <param name="momentum"></param>
/// <param name="epsilon"></param>
/// <param name="center"></param>
/// <param name="scale"></param>
/// <param name="beta_initializer"></param>
/// <param name="gamma_initializer"></param>
/// <param name="moving_mean_initializer"></param>
/// <param name="moving_variance_initializer"></param>
/// <param name="training"></param>
/// <param name="trainable"></param>
/// <param name="name"></param>
/// <param name="renorm"></param>
/// <param name="renorm_momentum"></param>
/// <returns></returns>
public Tensor batch_normalization(Tensor inputs,
int axis = -1,
float momentum = 0.99f,
float epsilon = 0.001f,
bool center = true,
bool scale = true,
IInitializer beta_initializer = null,
IInitializer gamma_initializer = null,
IInitializer moving_mean_initializer = null,
IInitializer moving_variance_initializer = null,
Tensor training = null,
bool trainable = true,
string name = null,
bool renorm = false,
float renorm_momentum = 0.99f)
{
var layer = new BatchNormalization(
axis: axis,
momentum: momentum,
epsilon: epsilon,
center: center,
scale: scale,
beta_initializer: beta_initializer,
gamma_initializer: gamma_initializer,
moving_mean_initializer: moving_mean_initializer,
moving_variance_initializer: moving_variance_initializer,
renorm: renorm,
renorm_momentum: renorm_momentum,
trainable: trainable,
name: name);
return(layer.apply(inputs, training: training).Item1);
}
static BatchNormalization <T> SetupBatchnorm <T>(BatchNormParameter param, List <BlobProto> blobs, string name, string[] inputNames, string[] outputNames) where T : unmanaged, IComparable <T>
{
TVal <T> decay = (TVal <T>)param.MovingAverageFraction;
TVal <T> eps = (TVal <T>)param.Eps;
int size = (int)blobs[0].Shape.Dims[0];
float[] avgMean = blobs[0].Datas;
float[] avgVar = blobs[1].Datas;
if (blobs.Count >= 3)
{
float scalingFactor = blobs[2].Datas[0];
for (int i = 0; i < avgMean.Length; i++)
{
avgMean[i] /= scalingFactor;
}
for (int i = 0; i < avgVar.Length; i++)
{
avgVar[i] /= scalingFactor;
}
}
BatchNormalization <T> batchNormalization = new BatchNormalization <T>(size, decay, eps, name: name, inputNames: inputNames, outputNames: outputNames);
Array.Copy(avgMean, batchNormalization.AvgMean.Data, avgMean.Length);
Array.Copy(avgVar, batchNormalization.AvgVar.Data, avgVar.Length);
return(batchNormalization);
}
public static void LoadWeight(this BatchNormalization layer, KerasLayerWeightJson[] weightsKernel)
{
layer.WeightShape.x = weightsKernel[0].shape[0];
layer.weightcache = new float[(int)layer.WeightShape.x * 4];
for (int i = 0; i < layer.WeightShape.x; i++)
{
layer.weightcache[i * 4] = weightsKernel[0].arrayweight[i];
layer.weightcache[i * 4 + 1] = weightsKernel[1].arrayweight[i];
layer.weightcache[i * 4 + 2] = weightsKernel[2].arrayweight[i];
layer.weightcache[i * 4 + 3] = weightsKernel[3].arrayweight[i];
}
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is BatchNormalization)
{
BatchNormalization bnm = descriptor as BatchNormalization;
ILayer layer = new BatchNormLayer(bnm.Epsilon);
return(layer);
}
return(null);
}
private Layer ConvertBatchNorm(paddle.OpDesc op)
{
var epsilon = GetAttr(op, "epsilon").F;
var offset = GetParameter(op.Inputs, "Bias").Arguments[0];
var mean = GetParameter(op.Inputs, "Mean").Arguments[0];
var scale = GetParameter(op.Inputs, "Scale").Arguments[0];
var variance = GetParameter(op.Inputs, "Variance").Arguments[0];
var x = GetParameter(op.Inputs, "X").Arguments[0];
var output = GetParameter(op.Outputs, "Y").Arguments[0];
var layer = new BatchNormalization(GetVarShape(x), LoadVarData <float>(scale), LoadVarData <float>(offset),
LoadVarData <float>(mean), LoadVarData <float>(variance), epsilon);
_inputs.Add(layer.Input, x);
_outputs.Add(output, layer.Output);
return(layer);
}
private Layer ConvertBatchNorm(LayerParameter layerParam)
{
var input = _outputs[layerParam.Bottom[0]];
var param = layerParam.BatchNormParam;
var eps = param == null || param.Eps == 0 ? 1e-5f : param.Eps;
var scaleFactor = LoadBlob(layerParam.Blobs[2])[0];
var mean = LoadBlob(layerParam.Blobs[0], scaleFactor);
var variance = LoadBlob(layerParam.Blobs[1], scaleFactor);
var scale = Enumerable.Repeat(1.0f, mean.Dimensions[0]).ToArray().ToTensor();
var offset = Enumerable.Repeat(0.0f, mean.Dimensions[0]).ToArray().ToTensor();
var layer = new BatchNormalization(input.Dimensions, scale, offset, mean, variance, eps);
layer.Input.SetConnection(input);
_outputs[layerParam.Top[0]] = layer.Output;
return(layer);
}
public Illustration2Vec()
{
var inputTensor = new InputLayer(new int?[] { 224, 224, 3 });
var vgg16_model = VGG16Model.CreateModel("");
foreach (var layer in vgg16_model.layers.Take(12))
{
layer.trainable = false;
}
var x = vgg16_model.layers.Last().output;
// List <KerasSharp.Engine.Topology.Tensor> x = null;
x = new Flatten().Call(x);
x = new BatchNormalization().Call(x);
x = new Dense(5000, activation: "relu").Call(x);
x = new Dropout(0.3).Call(x);
x = new Dense(5000, activation: "sigmoid").Call(x);
model = new Model(vgg16_model.input, x, "altI2v");
model.Compile(new Adam(), new BinaryCrossEntropy());
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <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);
}
}
}
private List <IKernelDescriptor> ReadDescriptors(JObject model)
{
List <IKernelDescriptor> dscps = model.SelectToken("descriptors").Select(layer => {
IKernelDescriptor descriptor = null;
String layerName = (String)layer.SelectToken("layer");
switch (layerName)
{
case "AvgPooling1D":
descriptor = new AvgPooling1D(
(int)layer.SelectToken("padding"),
(int)layer.SelectToken("stride"),
(int)layer.SelectToken("kernel_size"));
break;
case "GlobalAveragePooling1D":
descriptor = new GlobalAvgPooling1D();
break;
case "AvgPooling2D":
descriptor = new AvgPooling2D((int)layer.SelectToken("padding_vl"), (int)layer.SelectToken("padding_hz"),
(int)layer.SelectToken("stride_vl"), (int)layer.SelectToken("stride_hz"),
(int)layer.SelectToken("kernel_height"), (int)layer.SelectToken("kernel_width"));
break;
case "GlobalAveragePooling2D":
descriptor = new GlobalAvgPooling2D();
break;
case "BatchNormalization":
descriptor = new BatchNormalization(
(int)layer.SelectToken("epsilon"));
break;
case "Cropping1D":
descriptor = new Cropping1D(
(int)layer.SelectToken("trimBegin"),
(int)layer.SelectToken("trimEnd"));
break;
case "Cropping2D":
descriptor = new Cropping2D(
(int)layer.SelectToken("topTrim"),
(int)layer.SelectToken("bottomTrim"),
(int)layer.SelectToken("leftTrim"),
(int)layer.SelectToken("rightTrim"));
break;
case "MaxPooling1D":
descriptor = new MaxPooling1D(
(int)layer.SelectToken("padding"),
(int)layer.SelectToken("stride"),
(int)layer.SelectToken("kernel_size"));
break;
case "GlobalMaxPooling1D":
descriptor = new GlobalMaxPooling1D();
break;
case "MaxPooling2D":
descriptor = new MaxPooling2D((int)layer.SelectToken("padding_vl"), (int)layer.SelectToken("padding_hz"),
(int)layer.SelectToken("stride_vl"), (int)layer.SelectToken("stride_hz"),
(int)layer.SelectToken("kernel_height"), (int)layer.SelectToken("kernel_width"));
break;
case "GlobalMaxPooling2D":
descriptor = new GlobalMaxPooling2D();
break;
case "Convolution1D":
descriptor = new Convolution1D(
(int)layer.SelectToken("padding"),
(int)layer.SelectToken("stride"),
(int)layer.SelectToken("kernel_size"),
(int)layer.SelectToken("kernel_num"));
break;
case "Convolution2D":
descriptor = new Convolution2D((int)layer.SelectToken("padding_vl"), (int)layer.SelectToken("padding_hz"),
(int)layer.SelectToken("stride_vl"), (int)layer.SelectToken("stride_hz"),
(int)layer.SelectToken("kernel_height"), (int)layer.SelectToken("kernel_width"),
(int)layer.SelectToken("kernel_num"));
break;
case "Dense2D":
descriptor = new Dense2D((int)layer.SelectToken("units"));
break;
case "Input2D":
descriptor = new Input2D((int)layer.SelectToken("height"), (int)layer.SelectToken("width"),
(int)layer.SelectToken("channel"), (int)layer.SelectToken("batch"));
break;
case "Bias2D":
descriptor = new Bias2D();
break;
case "Permute":
descriptor = new Permute(
(int)layer.SelectToken("dim1"),
(int)layer.SelectToken("dim2"),
(int)layer.SelectToken("dim3"));
break;
case "Reshape":
descriptor = new Reshape2D(
(int)layer.SelectToken("height"),
(int)layer.SelectToken("width"),
(int)layer.SelectToken("channel"),
1);
break;
case "RepeatVector":
descriptor = new RepeatVector(
(int)layer.SelectToken("num"));
break;
case "SimpleRNN":
descriptor = new SimpleRNN(
(int)layer.SelectToken("units"),
(int)layer.SelectToken("input_dim"),
ANR((string)layer.SelectToken("activation")));
break;
case "LSTM":
descriptor = new LSTM(
(int)layer.SelectToken("units"),
(int)layer.SelectToken("input_dim"),
ANR((string)layer.SelectToken("activation")),
ANR((string)layer.SelectToken("rec_act")));
break;
case "GRU":
descriptor = new GRU(
(int)layer.SelectToken("units"),
(int)layer.SelectToken("input_dim"),
ANR((string)layer.SelectToken("activation")),
ANR((string)layer.SelectToken("rec_act")));
break;
case "ELu":
descriptor = new ELu(1);
break;
case "HardSigmoid":
descriptor = new HardSigmoid();
break;
case "ReLu":
descriptor = new ReLu();
break;
case "Sigmoid":
descriptor = new Sigmoid();
break;
case "Flatten":
descriptor = new Flatten();
break;
case "Softmax":
descriptor = new Softmax();
break;
case "SoftPlus":
descriptor = new SoftPlus();
break;
case "SoftSign":
descriptor = new Softsign();
break;
case "TanH":
descriptor = new TanH();
break;
default:
throw new Exception("Unknown layer type!");
}
return(descriptor);
}).ToList();
return(dscps);
}
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>();
}
}
static Function <T> CreateFunction <T>(NodeProto node, long version, List <TensorProto> initializers, int[] inputShape, ref int initilizerIndex, out int[] outputShape) where T : unmanaged, IComparable <T>
{
switch (node.OpType)
{
case "BatchNormalization":
if (version >= 9)
{
TensorProto bn_scale = initializers[initilizerIndex++];
TensorProto bn_b = initializers[initilizerIndex++];
TensorProto bn_mean = initializers[initilizerIndex++];
TensorProto bn_var = initializers[initilizerIndex++];
BatchNormalization <T> batchNormalization = new BatchNormalization <T>(
channelSize: bn_scale.FloatDatas.Length,
useGamma: true,
useBeta: true,
eps: (TVal <T>)node.GetAttribute("epsilon").F,
name: node.Name,
inputNames: new[] { node.Inputs[0] },
outputNames: new[] { node.Outputs[0] },
decay: (TVal <T>)node.GetAttribute("momentum").F
);
Array.Copy(bn_scale.FloatDatas, batchNormalization.Gamma.Data, bn_scale.FloatDatas.Length);
Array.Copy(bn_b.FloatDatas, batchNormalization.Beta.Data, bn_b.FloatDatas.Length);
Array.Copy(bn_mean.FloatDatas, batchNormalization.AvgMean.Data, bn_mean.FloatDatas.Length);
Array.Copy(bn_var.FloatDatas, batchNormalization.AvgVar.Data, bn_var.FloatDatas.Length);
outputShape = inputShape;
return(batchNormalization);
}
else if (version >= 7)
{
TensorProto bn_scale = initializers[initilizerIndex++];
TensorProto bn_b = initializers[initilizerIndex++];
TensorProto bn_mean = initializers[initilizerIndex++];
TensorProto bn_var = initializers[initilizerIndex++];
//[spatial]
// If true, compute the mean and variance across per activation.
// If false, compute the mean and variance across per feature over each mini - batch.
// 真の場合は、活性化ごとに平均と分散を計算します。
// falseの場合は，ミニバッチごとに特徴量ごとの平均と分散を計算します．
//将来Axis対応することがあればコメントアウトを外す
//int[] axis = {0};
//if (node.GetAttribute("spatial").I != 1)
//{
// List<int> tmp = new List<int>();
// tmp.Add(0); //ここの次元指定はミニバッチ数に当たる
// tmp.AddRange(Enumerable.Range(2, inputShape.Length - 2));
// axis = tmp.ToArray();
//}
BatchNormalization <T> batchNormalization = new BatchNormalization <T>(
channelSize: bn_scale.FloatDatas.Length,
eps: (TVal <T>)node.GetAttribute("epsilon").F,
name: node.Name,
inputNames: new[] { node.Inputs[0] },
outputNames: new[] { node.Outputs[0] },
decay: (TVal <T>)node.GetAttribute("momentum").F
//axis: axis
);
Array.Copy(bn_scale.FloatDatas, batchNormalization.Gamma.Data, bn_scale.FloatDatas.Length);
Array.Copy(bn_b.FloatDatas, batchNormalization.Beta.Data, bn_b.FloatDatas.Length);
Array.Copy(bn_mean.FloatDatas, batchNormalization.AvgMean.Data, bn_mean.FloatDatas.Length);
Array.Copy(bn_var.FloatDatas, batchNormalization.AvgVar.Data, bn_var.FloatDatas.Length);
outputShape = inputShape;
return(batchNormalization);
}
else if (version >= 6)
{
//[spatial]
//If true, compute the mean and variance across all spatial elements.
//If false, compute the mean and variance across per feature.
//真の場合、すべての空間要素の平均と分散を計算します。
//偽の場合は，特徴量ごとの平均と分散を計算します。
throw new NotImplementedException();
}
else if (version >= 1)
{
throw new NotImplementedException();
}
break;
case "Conv":
if (version >= 11)
{
throw new NotImplementedException();
}
else if (version >= 1)
{
TensorProto conv_w = initializers[initilizerIndex++];
TensorProto conv_b = null;
if (node.Inputs.Count > 2)
{
conv_b = initializers[initilizerIndex++];
}
outputShape = inputShape;
return(new Convolution2D <T>(
inputChannels: (int)conv_w.Dims[1],
outputChannels: (int)conv_w.Dims[0],
kernelSize: Array.ConvertAll(node.GetAttribute("kernel_shape").Ints, s => (int)s),
stride: Array.ConvertAll(node.GetAttribute("strides").Ints, s => (int)s),
pad: Array.ConvertAll(node.GetAttribute("pads").Ints, s => (int)s), //pads: [x1_begin, x2_begin...x1_end, x2_end,...]で入ってくるので使用するのは前2つ
noBias: node.Inputs.Count < 3,
initialW: conv_w.FloatDatas,
initialb: conv_b?.FloatDatas,
name: node.Name,
inputNames: new[] { node.Inputs[0] },
outputNames: new[] { node.Outputs[0] }));
}
break;
case "Dropout":
if (version >= 12)
{
throw new NotImplementedException();
}
else if (version >= 10)
{
throw new NotImplementedException();
}
else if (version >= 7)
{
outputShape = inputShape;
return(new Dropout <T>((TVal <T>)node.GetAttribute("ratio").F, name: node.Name, inputNames: new[] { node.Inputs[0] }, outputNames: new[] { node.Outputs[0] }));
}
else if (version >= 6)
{
throw new NotImplementedException();
}
else if (version >= 1)
{
throw new NotImplementedException();
}
break;
case "Flatten":
outputShape = inputShape; //厳密には変わるが、関数内で吸収されるため不要
return(null);
case "Gemm":
if (version >= 11)
{
throw new NotImplementedException();
}
else if (version >= 9)
{
throw new NotImplementedException();
}
else if (version >= 7)
{
TensorProto w = initializers[initilizerIndex++];
TensorProto b = initializers[initilizerIndex++];
outputShape = new[]
{
inputShape[0], //バッチカウント
(int)w.Dims[0] //出力数
};
return(new Linear <T>(
inputCount: (int)w.Dims[1],
outputCount: (int)w.Dims[0],
name: node.Name,
inputNames: new[] { node.Inputs[0] },
outputNames: new[] { node.Outputs[0] },
noBias: false,
initialW: w.FloatDatas,
initialb: b.FloatDatas
));
}
else if (version >= 6)
{
throw new NotImplementedException();
}
else if (version >= 1)
{
throw new NotImplementedException();
}
break;
case "MaxPool":
if (version >= 12)
{
throw new NotImplementedException();
}
else if (version >= 11)
{
throw new NotImplementedException();
}
else if (version >= 10)
{
throw new NotImplementedException();
}
else if (version >= 8)
{
int[] kernelSize = Array.ConvertAll(node.GetAttribute("kernel_shape").Ints, s => (int)s);
int[] stride = Array.ConvertAll(node.GetAttribute("strides").Ints, s => (int)s);
int[] pad = Array.ConvertAll(node.GetAttribute("pads").Ints, s => (int)s);
List <int> tmpOutputShape = new List <int>();
tmpOutputShape.Add(inputShape[0]); //ミニバッチカウント
tmpOutputShape.Add(inputShape[1]); //チャンネル
tmpOutputShape.Add((int)Math.Floor((inputShape[2] - kernelSize[1] + pad[1] * 2.0f + stride[1] - 1.0f) / stride[1]) + 1);
tmpOutputShape.Add((int)Math.Floor((inputShape[3] - kernelSize[0] + pad[0] * 2.0f + stride[0] - 1.0f) / stride[0]) + 1);
outputShape = tmpOutputShape.ToArray();
return(new MaxPooling2D <T>(
kernelSize: kernelSize,
stride: stride,
pad: pad,
name: node.Name,
inputNames: new[] { node.Inputs[0] },
outputNames: new[] { node.Outputs[0] }
));
}
else if (version >= 1)
{
throw new NotImplementedException();
}
break;
case "Relu":
if (version >= 6)
{
outputShape = inputShape;
return(new ReLU <T>(name: node.Name, inputNames: new[] { node.Inputs[0] }, outputNames: new[] { node.Outputs[0] }));
}
else if (version >= 1)
{
throw new NotImplementedException();
}
break;
}
Console.WriteLine(node.OpType + "was not implemented.");
throw new NotImplementedException();
}
public void TrainTest(bool isTtrain, bool finetune)
{
Python.Initialize();
Chainer.Initialize();
int batchCount = Mother.Dice.Next(1, 50);
int ioCount = Mother.Dice.Next(1, 50);
Real[,] input = (Real[, ])Initializer.GetRealNdArray(new[] { batchCount, ioCount });
Real[,] dummyGy = (Real[, ])Initializer.GetRealNdArray(new[] { batchCount, ioCount });
Real[] gamma = Initializer.GetRealArray(ioCount);
Real[] beta = Initializer.GetRealArray(ioCount);
Real[] avgMean = Initializer.GetRealArray(ioCount);
Real[] avgVar = Initializer.GetRealArray(ioCount);
//Chainer
Chainer.Config["train"] = isTtrain;
NChainer.BatchNormalization <Real> cBatchNormalization = new NChainer.BatchNormalization <Real>(ioCount, dtype: Real.Type);
cBatchNormalization.gamma = new Variable <Real>(Real.ToBaseNdArray(gamma));
cBatchNormalization.beta = new Variable <Real>(Real.ToBaseNdArray(beta));
cBatchNormalization.avgMean = Real.ToBaseNdArray(avgMean);
cBatchNormalization.avgVar = Real.ToBaseNdArray(avgVar);
Variable <Real> cX = new Variable <Real>(Real.ToBaseNdArray(input));
Variable <Real> cY = cBatchNormalization.Forward(cX, finetune);
cY.Grad = Real.ToBaseNdArray(dummyGy);
cY.Backward();
//KelpNet
KelpNet.BatchNormalization batchNormalization = new BatchNormalization(ioCount, train: isTtrain, finetune: finetune);
batchNormalization.Gamma.Data = Real.ToRealArray(gamma);
batchNormalization.Beta.Data = Real.ToRealArray(beta);
batchNormalization.AvgMean.Data = Real.ToRealArray(avgMean);
batchNormalization.AvgVar.Data = Real.ToRealArray(avgVar);
NdArray x = new NdArray(Real.ToRealArray(input), new[] { ioCount }, batchCount);
NdArray y = batchNormalization.Forward(x)[0];
y.Grad = Real.ToRealArray(dummyGy);
y.Backward();
Real[] cYdata = Real.ToRealArray((Real[, ])cY.Data);
Real[] cXgrad = Real.ToRealArray((Real[, ])cX.Grad);
Real[] cGammaGrad = Real.ToRealArray((Real[])cBatchNormalization.gamma.Grad);
Real[] cBetaGrad = Real.ToRealArray((Real[])cBatchNormalization.beta.Grad);
//許容範囲を算出
double delta = 0.00001;
//y
Assert.AreEqual(cYdata.Length, y.Data.Length);
for (int i = 0; i < y.Data.Length; i++)
{
Assert.AreEqual(cYdata[i], y.Data[i], delta);
}
//x.grad
Assert.AreEqual(cXgrad.Length, x.Grad.Length);
for (int i = 0; i < x.Grad.Length; i++)
{
Assert.AreEqual(cXgrad[i], x.Grad[i], delta);
}
//gamma.grad
Assert.AreEqual(cGammaGrad.Length, batchNormalization.Gamma.Grad.Length);
for (int i = 0; i < batchNormalization.Gamma.Grad.Length; i++)
{
Assert.AreEqual(cGammaGrad[i], batchNormalization.Gamma.Grad[i], delta);
}
//beta.grad
Assert.AreEqual(cBetaGrad.Length, batchNormalization.Beta.Grad.Length);
for (int i = 0; i < batchNormalization.Beta.Grad.Length; i++)
{
Assert.AreEqual(cBetaGrad[i], batchNormalization.Beta.Grad[i], delta);
}
}
public void TrainTest(bool isTtrain, bool finetune)
{
Python.Initialize();
Chainer.Initialize();
int batchCount = Mother.Dice.Next(1, 50);
int ioCount = Mother.Dice.Next(1, 50);
Real[,] input = Initializer.GetRandomValues <Real[, ]>(batchCount, ioCount);
Real[,] dummyGy = Initializer.GetRandomValues <Real[, ]>(batchCount, ioCount);
Real[] gamma = Initializer.GetRandomValues <Real[]>(ioCount);
Real[] beta = Initializer.GetRandomValues <Real[]>(ioCount);
Real[] avgMean = Initializer.GetRandomValues <Real[]>(ioCount);
Real[] avgVar = Initializer.GetRandomValues <Real[]>(ioCount);
//Chainer
Chainer.Config["train"] = isTtrain;
NChainer.BatchNormalization <Real> cBatchNormalization = new NChainer.BatchNormalization <Real>(ioCount, dtype: typeof(Real));
cBatchNormalization.gamma = new Variable <Real>(gamma);
cBatchNormalization.beta = new Variable <Real>(beta);
cBatchNormalization.avgMean = avgMean;
cBatchNormalization.avgVar = avgVar;
Variable <Real> cX = new Variable <Real>(input);
Variable <Real> cY = cBatchNormalization.Forward(cX, finetune);
cY.Grad = dummyGy;
cY.Backward();
//KelpNet
KelpNet.BatchNormalization <Real> batchNormalization = new BatchNormalization <Real>(ioCount, train: isTtrain, finetune: finetune);
batchNormalization.Gamma.Data = gamma;
batchNormalization.Beta.Data = beta;
batchNormalization.AvgMean.Data = avgMean;
batchNormalization.AvgVar.Data = avgVar;
NdArray <Real> x = new NdArray <Real>(input, asBatch: true);
NdArray <Real> y = batchNormalization.Forward(x)[0];
y.Grad = dummyGy.Flatten();
y.Backward();
Real[] cYdata = ((Real[, ])cY.Data).Flatten();
Real[] cXgrad = ((Real[, ])cX.Grad).Flatten();
Real[] cGammaGrad = (Real[])cBatchNormalization.gamma.Grad;
Real[] cBetaGrad = (Real[])cBatchNormalization.beta.Grad;
//許容範囲を算出
Real delta = 0.00005f;
//y
Assert.AreEqual(cYdata.Length, y.Data.Length);
for (int i = 0; i < y.Data.Length; i++)
{
Assert.AreEqual(cYdata[i], y.Data[i], delta);
}
//x.grad
Assert.AreEqual(cXgrad.Length, x.Grad.Length);
for (int i = 0; i < x.Grad.Length; i++)
{
Assert.AreEqual(cXgrad[i], x.Grad[i], delta);
}
//gamma.grad
Assert.AreEqual(cGammaGrad.Length, batchNormalization.Gamma.Grad.Length);
for (int i = 0; i < batchNormalization.Gamma.Grad.Length; i++)
{
Assert.AreEqual(cGammaGrad[i], batchNormalization.Gamma.Grad[i], delta);
}
//beta.grad
Assert.AreEqual(cBetaGrad.Length, batchNormalization.Beta.Grad.Length);
for (int i = 0; i < batchNormalization.Beta.Grad.Length; i++)
{
Assert.AreEqual(cBetaGrad[i], batchNormalization.Beta.Grad[i], delta);
}
}
