public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is Sigmoid)
{
return(new SigmoidLayer());
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is Softmax)
{
return(new SoftmaxLayer());
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is ReLu)
{
return(new ReLuLayer());
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is Flatten)
{
return(new FlattenLayer());
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is TanH)
{
return(new TanHLayer());
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is LeakyReLu)
{
LeakyReLu leakyrelu = descriptor as LeakyReLu;
return(new LeakyReLuLayer(leakyrelu.Alpha));
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is Bias2D)
{
ILayer layer = new Bias2DLayer();
return(layer);
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is ELu)
{
ELu elu = descriptor as ELu;
return(new ELuLayer(elu.Alpha));
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is Reshape2D)
{
Reshape2D reshape = descriptor as Reshape2D;
ILayer layer = new Reshape2DLayer(reshape.Height, reshape.Width, reshape.Channel, reshape.Batch);
return(layer);
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is Convolution1D)
{
Convolution1D conv = descriptor as Convolution1D;
ILayer layer = new Conv1DLayer(conv.Padding, conv.Stride);
return(layer);
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is GlobalMaxPooling1D)
{
GlobalMaxPooling1D pool = descriptor as GlobalMaxPooling1D;
ILayer layer = new GlobalMaxPool1DLayer();
return(layer);
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is Cropping1D)
{
Cropping1D crop = descriptor as Cropping1D;
ILayer layer = new Cropping1DLayer(crop.TrimBegin, crop.TrimEnd);
return(layer);
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is BatchNormalization)
{
BatchNormalization bnm = descriptor as BatchNormalization;
ILayer layer = new BatchNormLayer(bnm.Epsilon);
return(layer);
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is RepeatVector)
{
RepeatVector repeat = descriptor as RepeatVector;
ILayer layer = new RepeatVectorLayer(repeat.Num);
return(layer);
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is Dropout)
{
Dropout dropout = descriptor as Dropout;
ILayer layer = new DropoutLayer(dropout.Rate, dropout.NoiseShape);
return(layer);
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is Permute)
{
Permute permute = descriptor as Permute;
ILayer layer = new PermuteLayer(permute.Dim1, permute.Dim2, permute.Dim3);
return(layer);
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is Cropping2D)
{
Cropping2D crop = descriptor as Cropping2D;
ILayer layer = new Cropping2DLayer(crop.TopTrim, crop.BottomTrim, crop.LeftTrim, crop.RightTrim);
return(layer);
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is Dense2D)
{
Dense2D dens = descriptor as Dense2D;
ILayer layer = new Dense2DLayer(dens.Units);
return(layer);
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is MaxPooling1D)
{
MaxPooling1D pool = descriptor as MaxPooling1D;
ILayer layer = new MaxPool1DLayer(pool.Padding, pool.Stride, pool.KernelSize);
return(layer);
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is SimpleRNN)
{
SimpleRNN rnn = descriptor as SimpleRNN;
ILayer layer = new SimpleRNNLayer(rnn.Units, rnn.InputDim, rnn.Lambda);
return(layer);
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is Convolution2D)
{
Convolution2D conv = descriptor as Convolution2D;
ILayer layer = new Conv2DLayer(conv.PaddingVertical, conv.PaddingHorizontal,
conv.StrideVertical, conv.StrideHorizontal);
return(layer);
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is GRU)
{
GRU rnn = descriptor as GRU;
ILayer layer = new GRULayer(rnn.Units, rnn.InputDim, rnn.Activation,
rnn.RecurrentActivation);
return(layer);
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is MinPooling2D)
{
MinPooling2D conv = descriptor as MinPooling2D;
ILayer layer = new MaxPool2DLayer(conv.PaddingVertical, conv.PaddingHorizontal,
conv.StrideVertical, conv.StrideHorizontal,
conv.KernelHeight, conv.KernelWidth);
return(layer);
}
return(null);
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
ILayer layer = null;
foreach (var fac in factories)
{
layer = fac.CreateProduct(descriptor);
if (layer != null)
{
return(layer);
}
}
throw new Exception("Layer type does not exist!");
}
public ILayer CreateProduct(IKernelDescriptor descriptor)
{
if (descriptor is Input2D)
{
Input2D inputDescriptor = descriptor as Input2D;
Data2D data = new Data2D(inputDescriptor.Height, inputDescriptor.Width,
inputDescriptor.Channels, inputDescriptor.Batch);
data.ToZeros();
Input2DLayer layer = new Input2DLayer();
layer.SetInput(data);
return(layer);
}
return(null);
}
public void Add(IKernelDescriptor descriptor)
{
descriptors.Add(descriptor);
}
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);
}
