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); } }