public static void Run() { var input = new Input(new Keras.Shape(32, 32)); //var a = new CuDNNLSTM(32).Set(input); var a = new Dense(32, activation: "sigmoid").Set(input); //a.Set(input); var output = new Dense(1, activation: "sigmoid").Set(a); //output.Set(a); var model = new Keras.Models.Model(new Input[] { input }, new BaseLayer[] { output }); //Load train data Numpy.NDarray x = np.array(new float[, ] { { 0, 0 }, { 0, 1 }, { 1, 0 }, { 1, 1 } }); NDarray y = np.array(new float[] { 0, 1, 1, 0 }); var input1 = new Input(new Shape(32, 32, 3)); var conv1 = new Conv2D(32, (4, 4).ToTuple(), activation: "relu").Set(input1); var pool1 = new MaxPooling2D((2, 2).ToTuple()).Set(conv1); var flatten1 = new Flatten().Set(pool1); var input2 = new Input(new Shape(32, 32, 3)); var conv2 = new Conv2D(16, (8, 8).ToTuple(), activation: "relu").Set(input2); var pool2 = new MaxPooling2D((2, 2).ToTuple()).Set(conv2); var flatten2 = new Flatten().Set(pool2); var merge = new Concatenate(flatten1, flatten2); }
public MobileNetV2(float multiplier = 1, int classes = 1000, string prefix = null, ParameterDict @params = null) : base(prefix, @params) { Features = new HybridSequential(""); MobileNet.AddConv(Features, Convert.ToInt32(32 * multiplier), 3, pad: 1, stride: 2); for (var i = 0; i < in_channels_group.Length; i++) { var in_c = Convert.ToInt32(multiplier * in_channels_group[i]); var c = Convert.ToInt32(multiplier * channels_group[i]); var s = strides[i]; var t = ts[i]; Features.Add(new LinearBottleneck(in_c, c, t, s)); } var last_channel = multiplier > 1 ? Convert.ToInt32(1280 * multiplier) : 1280; MobileNet.AddConv(Features, last_channel, relu6: true); Features.Add(new GlobalAvgPool2D()); Output = new HybridSequential("output_"); Output.Add(new Conv2D(classes, (1, 1), use_bias: false, prefix: "pred_")); Output.Add(new Flatten()); }
// Performs convolutional neural network model training: // Incorporated parameters include relu and softmax // Adds fixed preprocessing layers and pooling: could use further development with exposed parameters private static Sequential ProcessCnnModel(Shape input_shape, NDarray x_train, NDarray y_train, NDarray x_test, NDarray y_test, int num_classes, string logname, Config config) { // Build CNN model Sequential model = new Sequential(); model.Add(new Conv2D(16, kernel_size: (3, 3).ToTuple(), activation: "relu", input_shape: input_shape)); model.Add(new Conv2D(32, (3, 3).ToTuple(), activation: "relu")); model.Add(new MaxPooling2D(pool_size: (2, 2).ToTuple())); model.Add(new Flatten()); Callback[] callbacks = GetCallbacks(config.isEarlyStop, logname); AddNodes(model, config); model.Add(new Dense(num_classes, activation: "softmax")); // Compile with loss, metrics and optimizer model.Compile(loss: "categorical_crossentropy", optimizer: new Adam(lr: (float)config.LearnRate, decay: (float)config.LearnDecay), metrics: new[] { "accuracy" }); // Train the model model.Fit(x_train, y_train, batch_size: config.Batch, epochs: config.Epochs, verbose: 1, validation_data: new[] { x_test, y_test }, callbacks: callbacks); return(model); }
public BottleneckV1(int channels, int stride, bool downsample = false, int in_channels = 0, string prefix = "", ParameterDict @params = null) : base(prefix, @params) { var channel_one_fourth = Convert.ToInt32(channels / 4); body = new HybridSequential(""); body.Add(new Conv2D(channel_one_fourth, (1, 1), (stride, stride))); body.Add(new BatchNorm()); body.Add(new Activation(ActivationType.Relu)); body.Add(ResNet.Conv3x3(channel_one_fourth, 1, channel_one_fourth)); body.Add(new BatchNorm()); body.Add(new Activation(ActivationType.Relu)); body.Add(new Conv2D(channels, (1, 1), (1, 1))); body.Add(new BatchNorm()); if (downsample) { ds = new HybridSequential(); ds.Add(new Conv2D(channels, (1, 1), (stride, stride), use_bias: false, in_channels: in_channels)); ds.Add(new BatchNorm()); RegisterChild(ds, "downsample"); } else { ds = null; } RegisterChild(body, "body"); }
public DUC(int planes, int upscale_factor = 2, string prefix = null, ParameterDict @params = null) : base(prefix, @params) { this.conv = new Conv2D(planes, kernel_size: (3, 3), padding: (1, 1), use_bias: false); this.bn = new BatchNormCudnnOff(gamma_initializer: "ones", beta_initializer: "zeros"); this.relu = new Activation(ActivationType.Relu); this.pixel_shuffle = new PixelShuffle2D((upscale_factor, upscale_factor)); }
public BottleneckV2(int channels, int stride, bool downsample = false, int in_channels = 0, string prefix = "", ParameterDict @params = null) : base(prefix, @params) { var channel_one_fourth = Convert.ToInt32(channels / 4); bn1 = new BatchNorm(); conv1 = new Conv2D(channel_one_fourth, (1, 1), (1, 1), use_bias: false); bn2 = new BatchNorm(); conv2 = ResNet.Conv3x3(channel_one_fourth, stride, channel_one_fourth); bn3 = new BatchNorm(); conv3 = new Conv2D(channels, (1, 1), (1, 1), use_bias: false); RegisterChild(bn1, "bn1"); RegisterChild(conv1, "conv1"); RegisterChild(bn2, "bn2"); RegisterChild(conv2, "conv2"); RegisterChild(bn3, "bn3"); RegisterChild(conv3, "conv3"); if (downsample) { ds = new Conv2D(channels, (1, 1), (stride, stride), use_bias: false, in_channels: in_channels); RegisterChild(ds, "downsample"); } else { ds = null; } }
public ResNetV1(string block, int[] layers, int[] channels, int classes = 1000, bool thumbnail = false, string prefix = "", ParameterDict @params = null) : base(prefix, @params) { if (layers.Length != channels.Length - 1) { throw new Exception("layers.length should be equal to channels.length - 1"); } Features = new HybridSequential(); if (thumbnail) { Features.Add(ResNet.Conv3x3(channels[0], 1, 0)); } else { Features.Add(new Conv2D(channels[0], (7, 7), (2, 2), (3, 3), use_bias: false)); Features.Add(new BatchNorm()); Features.Add(new Activation(ActivationType.Relu)); Features.Add(new MaxPool2D((3, 3), (2, 2), (1, 1))); } for (var i = 0; i < layers.Length; i++) { var stride = i == 0 ? 1 : 2; var num_layer = layers[i]; Features.Add(MakeLayer(block, num_layer, channels[i + 1], stride, i + 1, channels[i])); } Features.Add(new GlobalAvgPool2D()); Output = new Dense(classes, in_units: channels.Last()); RegisterChild(Features, "features"); RegisterChild(Output, "output"); }
public SqueezeNet(string version, int classes = 1000, string prefix = "", ParameterDict @params = null) : base(prefix, @params) { if (version != "1.0" && version != "1.1") { throw new NotSupportedException("Unsupported version"); } Features = new HybridSequential(); if (version == "1.0") { Features.Add(new Conv2D(96, (7, 7), (2, 2))); Features.Add(new Activation(ActivationType.Relu)); Features.Add(new MaxPool2D((3, 3), (2, 2), ceil_mode: true)); Features.Add(MakeFire(16, 64, 64)); Features.Add(MakeFire(16, 64, 64)); Features.Add(MakeFire(32, 128, 128)); Features.Add(new MaxPool2D((3, 3), (2, 2), ceil_mode: true)); Features.Add(MakeFire(32, 128, 128)); Features.Add(MakeFire(48, 192, 192)); Features.Add(MakeFire(48, 192, 192)); Features.Add(MakeFire(64, 256, 256)); Features.Add(new MaxPool2D((3, 3), (2, 2), ceil_mode: true)); Features.Add(MakeFire(64, 256, 256)); } else if (version == "1.1") { Features.Add(new Conv2D(64, (3, 3), (2, 2))); Features.Add(new Activation(ActivationType.Relu)); Features.Add(new MaxPool2D((3, 3), (2, 2), ceil_mode: true)); Features.Add(MakeFire(16, 64, 64)); Features.Add(MakeFire(16, 64, 64)); Features.Add(new MaxPool2D((3, 3), (2, 2), ceil_mode: true)); Features.Add(MakeFire(32, 128, 128)); Features.Add(MakeFire(32, 128, 128)); Features.Add(new MaxPool2D((3, 3), (2, 2), ceil_mode: true)); Features.Add(MakeFire(48, 192, 192)); Features.Add(MakeFire(48, 192, 192)); Features.Add(MakeFire(64, 256, 256)); Features.Add(MakeFire(64, 256, 256)); } Features.Add(new Dropout(0.5f)); RegisterChild(Features, "features"); Output = new HybridSequential(); Output.Add(new Conv2D(classes, (1, 1))); Output.Add(new Activation(ActivationType.Relu)); Output.Add(new AvgPool2D((13, 13))); Output.Add(new Flatten()); RegisterChild(Output, "output"); }
protected ValueTuple <Tensor, List <Tensor> > CreateVisualEncoder(Tensor visualInput, List <SimpleDenseLayerDef> denseLayers, string scope) { //use the same encoder as in UnityML's python codes Tensor temp; List <Tensor> returnWeights = new List <Tensor>(); using (Current.K.name_scope(scope)) { var conv1 = new Conv2D(16, new int[] { 8, 8 }, new int[] { 4, 4 }, use_bias: visualEncoderBias, kernel_initializer: new GlorotUniform(scale: visualEncoderInitialScale), activation: new ELU()); var conv2 = new Conv2D(32, new int[] { 4, 4 }, new int[] { 2, 2 }, use_bias: visualEncoderBias, kernel_initializer: new GlorotUniform(scale: visualEncoderInitialScale), activation: new ELU()); temp = conv1.Call(visualInput)[0]; temp = conv2.Call(temp)[0]; var flatten = new Flatten(); //temp = Current.K.batch_flatten(temp); temp = flatten.Call(temp)[0]; returnWeights.AddRange(conv1.weights); returnWeights.AddRange(conv2.weights); } var output = BuildSequentialLayers(denseLayers, temp, scope); var hiddenFlat = output.Item1; returnWeights.AddRange(output.Item2); return(ValueTuple.Create(hiddenFlat, returnWeights)); }
public static void LoadWeight(this Conv2D layer, KerasLayerWeightJson[] weightsKernel) { Vector4 WeightShape = new Vector4(weightsKernel[0].shape[0], weightsKernel[0].shape[1], weightsKernel[0].shape[2], weightsKernel[0].shape[3]); layer.WeightShape = WeightShape; int kernel_weight_length = (int)(WeightShape.x * WeightShape.y * WeightShape.z * WeightShape.w); int bias_weight_length = (int)WeightShape.w; layer.weightcache = new float[kernel_weight_length + bias_weight_length]; for (int i = 0; i < WeightShape.x; i++) { for (int j = 0; j < WeightShape.y; j++) { for (int k = 0; k < WeightShape.z; k++) { for (int w = 0; w < WeightShape.w; w++) { float arrayindex = i * WeightShape.y * WeightShape.z * WeightShape.w + j * WeightShape.z * WeightShape.w + k * WeightShape.w + w; layer.weightcache[(int)arrayindex] = weightsKernel[0].kernelweight[i, j, k, w]; } } } } Array.Copy(weightsKernel[1].arrayweight, 0, layer.weightcache, kernel_weight_length, bias_weight_length); }
// https://github.com/keras-team/keras/blob/49f5b931410bc2e56378f20a15e8ac919e0efb88/keras/applications/vgg16.py // WEIGHTS_PATH_NO_TOP = 'https://github.com/fchollet/deep-learning-models/releases/download/v0.1/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5' /// <summary> /// モデル作って返します。 /// </summary> /// <returns></returns> public static Model CreateModel(string weightFile) { var img_input = Python.Input(new int?[] { 224, 224, 3 }); var x = new Conv2D(64, new[] { 3, 3 }, activation: new ReLU(), padding: PaddingType.Same).Call(img_input); x = new Conv2D(64, new[] { 3, 3 }, activation: new ReLU(), padding: PaddingType.Same).Call(x); x = new MaxPooling2D(new int[] { 2, 2 }).Call(x); x = new Conv2D(128, new[] { 3, 3 }, activation: new ReLU(), padding: PaddingType.Same).Call(x); x = new Conv2D(128, new[] { 3, 3 }, activation: new ReLU(), padding: PaddingType.Same).Call(x); x = new MaxPooling2D(new int[] { 2, 2 }).Call(x); x = new Conv2D(256, new[] { 3, 3 }, activation: new ReLU(), padding: PaddingType.Same).Call(x); x = new Conv2D(256, new[] { 3, 3 }, activation: new ReLU(), padding: PaddingType.Same).Call(x); x = new Conv2D(256, new[] { 3, 3 }, activation: new ReLU(), padding: PaddingType.Same).Call(x); x = new MaxPooling2D(new int[] { 2, 2 }).Call(x); x = new Conv2D(512, new[] { 3, 3 }, activation: new ReLU(), padding: PaddingType.Same).Call(x); x = new Conv2D(512, new[] { 3, 3 }, activation: new ReLU(), padding: PaddingType.Same).Call(x); x = new Conv2D(512, new[] { 3, 3 }, activation: new ReLU(), padding: PaddingType.Same).Call(x); x = new MaxPooling2D(new int[] { 2, 2 }).Call(x); x = new Conv2D(512, new[] { 3, 3 }, activation: new ReLU(), padding: PaddingType.Same).Call(x); x = new Conv2D(512, new[] { 3, 3 }, activation: new ReLU(), padding: PaddingType.Same).Call(x); x = new Conv2D(512, new[] { 3, 3 }, activation: new ReLU(), padding: PaddingType.Same).Call(x); x = new MaxPooling2D(new int[] { 2, 2 }).Call(x); var model = new Model(img_input, x, "vgg16"); model.LoadWeightsH5(weightFile); return(model); }
public static Model CreateModel(int classCount) { var activation = tf.keras.activations.elu_fn; const int filterCount = 8; int[] resNetFilters = { filterCount, filterCount, filterCount }; return(new Sequential(new Layer[] { new Dropout(rate: 0.05), Conv2D.NewDyn(filters: filterCount, kernel_size: 5, padding: "same"), Activation.NewDyn(activation), new MaxPool2D(pool_size: 2), new ResNetBlock(kernelSize: 3, filters: resNetFilters, activation: activation), new ResNetBlock(kernelSize: 3, filters: resNetFilters, activation: activation), new ResNetBlock(kernelSize: 3, filters: resNetFilters, activation: activation), new ResNetBlock(kernelSize: 3, filters: resNetFilters, activation: activation), new MaxPool2D(), new ResNetBlock(kernelSize: 3, filters: resNetFilters, activation: activation), new ResNetBlock(kernelSize: 3, filters: resNetFilters, activation: activation), new MaxPool2D(), new ResNetBlock(kernelSize: 3, filters: resNetFilters, activation: activation), new ResNetBlock(kernelSize: 3, filters: resNetFilters, activation: activation), new AvgPool2D(pool_size: 2), new Flatten(), new Dense(units: classCount, activation: tf.nn.softmax_fn), })); }
public BasicBlockV2(int channels, int stride, bool downsample = false, int in_channels = 0, string prefix = null, ParameterDict @params = null) : base(prefix, @params) { bn1 = new BatchNorm(); conv1 = ResNet.Conv3x3(channels, stride, in_channels); bn2 = new BatchNorm(); conv2 = ResNet.Conv3x3(channels, 1, in_channels); if (downsample) { ds = new Conv2D(channels, (1, 1), (stride, stride), use_bias: false, in_channels: in_channels); } else { ds = null; } }
public static Tensor conv2d(Tensor inputs, int filters, int[] kernel_size, int[] strides = null, string padding = "valid", string data_format = "channels_last", int[] dilation_rate = null, bool use_bias = true, IActivation activation = null, IInitializer kernel_initializer = null) { if (strides == null) { strides = new int[] { 1, 1 } } ; if (dilation_rate == null) { dilation_rate = new int[] { 1, 1 } } ; var layer = new Conv2D(filters, kernel_size); return(layer.apply(inputs)); } } }
public static BaseModel GenerateModel() { var model = new Sequential(); model.Add(new Conv2D(64, kernel_size: (3, 3).ToTuple(), activation: "relu", padding: "same", input_shape: (9, 9, 1))); model.Add(new BatchNormalization()); model.Add(new Conv2D(64, kernel_size: (3, 3).ToTuple(), activation: "relu", padding: "same")); model.Add(new BatchNormalization()); model.Add(new Conv2D(128, kernel_size: (1, 1).ToTuple(), activation: "relu", padding: "same")); model.Add(new Flatten()); model.Add(new Dense(81 * 9)); model.Add(new Reshape((-1, 9))); model.Add(new Activation("softmax")); return(model); }
public ResNetBlock(int kernelSize, int[] filters) { for (int part = 0; part < PartCount; part++) { this.convs.Add(this.Track(part == 1 ? Conv2D.NewDyn(filters[part], kernel_size: kernelSize, padding: "same") : Conv2D.NewDyn(filters[part], kernel_size: (1, 1)))); this.batchNorms.Add(this.Track(new BatchNormalization())); } }
public BasicBlockV1(int channels, int stride, bool downsample = false, int in_channels = 0, string prefix = null, ParameterDict @params = null) : base(prefix, @params) { body = new HybridSequential(""); body.Add(ResNet.Conv3x3(channels, stride, in_channels)); body.Add(new BatchNorm()); body.Add(new Activation(ActivationType.Relu)); body.Add(ResNet.Conv3x3(channels, 1, in_channels)); body.Add(new BatchNorm()); if (downsample) { ds = new HybridSequential(); ds.Add(new Conv2D(channels, (1, 1), (stride, stride), use_bias: false, in_channels: in_channels)); ds.Add(new BatchNorm()); } else { ds = null; } }
public void Train() { // Build CNN model _model.Add(new Conv2D(32, kernel_size: (3, 3).ToTuple(), padding: Settings.PaddingMode, input_shape: new Shape(Settings.ImgWidth, Settings.ImgHeight, Settings.Channels))); _model.Add(new Activation(Settings.ActivationFunction)); _model.Add(new Conv2D(32, (3, 3).ToTuple())); _model.Add(new Activation(Settings.ActivationFunction)); _model.Add(new MaxPooling2D(pool_size: (2, 2).ToTuple())); _model.Add(new Dropout(0.25)); _model.Add(new Conv2D(64, kernel_size: (3, 3).ToTuple(), padding: Settings.PaddingMode)); _model.Add(new Activation(Settings.ActivationFunction)); _model.Add(new Conv2D(64, (3, 3).ToTuple())); _model.Add(new Activation(Settings.ActivationFunction)); _model.Add(new MaxPooling2D(pool_size: (2, 2).ToTuple())); _model.Add(new Dropout(0.25)); _model.Add(new Flatten()); _model.Add(new Dense(Settings.FullyConnectedNodes)); _model.Add(new Activation(Settings.ActivationFunction)); _model.Add(new Dropout(0.5)); _model.Add(new Dense(_dataset.NumberClasses)); _model.Add(new Softmax()); _model.Compile(loss: Settings.LossFunction, optimizer: Settings.Optimizer, metrics: new string[] { Settings.Accuracy }); _model.Fit(_dataset.TrainX, _dataset.TrainY, batch_size: Settings.BatchSize, epochs: Settings.Epochs, validation_data: new NDarray[] { _dataset.ValidationX, _dataset.ValidationY }); var score = _model.Evaluate(_dataset.ValidationX, _dataset.ValidationY, verbose: 0); Console.WriteLine("Test loss:" + score[0]); Console.WriteLine("Test accuracy:" + score[1]); }
public ResNetBlock(int kernelSize, int[] filters, PythonFunctionContainer?activation = null) { this.activation = activation ?? tf.keras.activations.relu_fn; for (int part = 0; part < PartCount; part++) { this.convs.Add(this.Track(part == 1 ? Conv2D.NewDyn(filters: filters[part], kernel_size: kernelSize, padding: "same") : Conv2D.NewDyn(filters[part], kernel_size: (1, 1)))); this.batchNorms.Add(this.Track(new BatchNormalization())); } this.outputChannels = filters[PartCount - 1]; }
public AlexNet(int classes = 1000, string prefix = "", ParameterDict @params = null) : base(prefix, @params) { Features = new HybridSequential(prefix); Features.Add(new Conv2D(64, (11, 11), (4, 4), (2, 2), activation: ActivationType.Relu)); Features.Add(new MaxPool2D((3, 3), (2, 2))); Features.Add(new Conv2D(192, (5, 5), padding: (2, 2), activation: ActivationType.Relu)); Features.Add(new MaxPool2D((3, 3), (2, 2))); Features.Add(new Conv2D(384, (3, 3), padding: (1, 1), activation: ActivationType.Relu)); Features.Add(new Conv2D(256, (3, 3), padding: (1, 1), activation: ActivationType.Relu)); Features.Add(new Conv2D(256, (3, 3), padding: (1, 1), activation: ActivationType.Relu)); Features.Add(new MaxPool2D((3, 3), (2, 2))); Features.Add(new Flatten()); Features.Add(new Dense(4096, ActivationType.Relu)); Features.Add(new Dropout(0.5f)); Features.Add(new Dense(4096, ActivationType.Relu)); Features.Add(new Dropout(0.5f)); Output = new Dense(classes); RegisterChild(Features); RegisterChild(Output); }
static void identity_block(input_tensor, kernel_size, filters, stage, block) { //KerasSharp.Backends.Current.Switch("KerasSharp.Backends.TensorFlowBackend"); // var bn_axis = 3; var filters1, filters2, filters3 = filters; var conv_name_base = "res" + str(stage) + block + "_branch"; var bn_name_base = "bn" + str(stage) + block + "_branch"; var x = new Conv2D(filters1, (1,1), name:conv_name_base + "2a")(input_tensor); x = x.add(new BatchNormalization(axis:bn_axis, name:bn_name_base + "2a")(x)); x = x.add(new activation: ReLU())(x)); x = x.add(new Conv2D(filters2, kernel_size, padding:"same", name:conv_name_base + "2b")(x)); x = x.add(new BatchNormalization(axis:bn_axis, name:bn_name_base + "2b")(x)); x = x.add(new activation: ReLU())(x)); x = x.add(new Conv2D(filters3, (1,1), name:conv_name_base + "2c")(x)); x = x.add(new BatchNormalization(axis:bn_axis, name:bn_name_base + "2c")(x)); x = x.add(activation: new ReLU())(x)); return x; }
public Tensor conv2d(Tensor inputs, int filters, int[] kernel_size, int[] strides = null, string padding = "valid", string data_format = "channels_last", int[] dilation_rate = null, bool use_bias = true, Activation activation = null, IInitializer kernel_initializer = null, IInitializer bias_initializer = null, bool trainable = true, string name = null) { if (strides == null) { strides = new int[] { 1, 1 } } ; if (dilation_rate == null) { dilation_rate = new int[] { 1, 1 } } ; if (bias_initializer == null) { bias_initializer = tf.zeros_initializer; } var layer = new Conv2D(new Conv2DArgs { Filters = filters, KernelSize = kernel_size, Strides = strides, Padding = padding, DataFormat = data_format, DilationRate = dilation_rate, Activation = activation, UseBias = use_bias, KernelInitializer = kernel_initializer, BiasInitializer = bias_initializer, Trainable = trainable, Name = name }); return(layer.Apply(inputs)); }
public static Tensor conv2d(Tensor inputs, int filters, int[] kernel_size, int[] strides = null, string padding = "valid", string data_format = "channels_last", int[] dilation_rate = null, bool use_bias = true, IActivation activation = null, IInitializer kernel_initializer = null, IInitializer bias_initializer = null, bool trainable = true, string name = null) { if (strides == null) { strides = new int[] { 1, 1 } } ; if (dilation_rate == null) { dilation_rate = new int[] { 1, 1 } } ; if (bias_initializer == null) { bias_initializer = tf.zeros_initializer; } var layer = new Conv2D(filters, kernel_size: kernel_size, strides: strides, padding: padding, data_format: data_format, dilation_rate: dilation_rate, activation: activation, use_bias: use_bias, kernel_initializer: kernel_initializer, bias_initializer: bias_initializer, trainable: trainable, name: name); return(layer.apply(inputs)); } } }
public void TestConv2D() { var inputLayer = UnityTFUtils.Input(shape: new int?[] { 32, 32, 3 }); var conv1 = new Conv2D(16, new int[] { 3, 3 }, padding: PaddingType.Same, activation: new ReLU()); var conv2 = new Conv2D(3, new int[] { 3, 3 }, padding: PaddingType.Same, activation: new ReLU()); var target = UnityTFUtils.Input(shape: new int?[] { 32, 32, 3 }); var pred = conv2.Call(conv1.Call(inputLayer[0])[0])[0]; var lossM = new MeanSquareError(); lossM.Call(target[0], pred); ((UnityTFBackend)K).ExportGraphDef("SavedGraph/convLayer.pb"); }
public static void Run() { int batch_size = 128; int num_classes = 10; int epochs = 100; // the data, split between train and test sets var((x_train, y_train), (x_test, y_test)) = Cifar10.LoadData(); Console.WriteLine("x_train shape: " + x_train.shape); Console.WriteLine(x_train.shape[0] + " train samples"); Console.WriteLine(x_test.shape[0] + " test samples"); // convert class vectors to binary class matrices y_train = Util.ToCategorical(y_train, num_classes); y_test = Util.ToCategorical(y_test, num_classes); // Build CNN model var model = new Sequential(); model.Add(new Conv2D(32, kernel_size: (3, 3).ToTuple(), padding: "same", input_shape: new Shape(32, 32, 3))); model.Add(new Activation("relu")); model.Add(new Conv2D(32, (3, 3).ToTuple())); model.Add(new Activation("relu")); model.Add(new MaxPooling2D(pool_size: (2, 2).ToTuple())); model.Add(new Dropout(0.25)); model.Add(new Conv2D(64, kernel_size: (3, 3).ToTuple(), padding: "same")); model.Add(new Activation("relu")); model.Add(new Conv2D(64, (3, 3).ToTuple())); model.Add(new Activation("relu")); model.Add(new MaxPooling2D(pool_size: (2, 2).ToTuple())); model.Add(new Dropout(0.25)); model.Add(new Flatten()); model.Add(new Dense(512)); model.Add(new Activation("relu")); model.Add(new Dropout(0.5)); model.Add(new Dense(num_classes)); model.Add(new Activation("softmax")); model.Compile(loss: "categorical_crossentropy", optimizer: new RMSprop(lr: 0.0001f, decay: 1e-6f), metrics: new string[] { "accuracy" }); x_train = x_train.astype(np.float32); x_test = x_test.astype(np.float32); x_train /= 255; x_test /= 255; model.Fit(x_train, y_train, batch_size: batch_size, epochs: epochs, verbose: 1, validation_data: new NDarray[] { x_test, y_test }, shuffle: true); //Save model and weights //string model_path = "./model.json"; //string weight_path = "./weights.h5"; //string json = model.ToJson(); //File.WriteAllText(model_path, json); //model.SaveWeight(weight_path); model.Save("model.h5"); model.SaveTensorflowJSFormat("./"); //Score trained model. var score = model.Evaluate(x_test, y_test, verbose: 0); Console.WriteLine("Test loss:" + score[0]); Console.WriteLine("Test accuracy:" + score[1]); }
public static void RunConv() { var mnist = TestUtils.GetMNIST(); var batch_size = 128; var train_data = new NDArrayIter(mnist["train_data"], mnist["train_label"], batch_size, true); var val_data = new NDArrayIter(mnist["test_data"], mnist["test_label"], batch_size); var net = new Sequential(); net.Add(new Conv2D(20, kernel_size: (5, 5), activation: ActivationType.Tanh)); net.Add(new MaxPool2D(pool_size: (2, 2), strides: (2, 2))); net.Add(new Conv2D(50, kernel_size: (5, 5), activation: ActivationType.Tanh)); net.Add(new MaxPool2D(pool_size: (2, 2), strides: (2, 2))); net.Add(new Flatten()); net.Add(new Dense(500, ActivationType.Tanh)); net.Add(new Dense(10)); var gpus = TestUtils.ListGpus(); var ctx = gpus.Count > 0 ? gpus.Select(x => Context.Gpu(x)).ToArray() : new[] { Context.Cpu(0) }; net.Initialize(new Xavier(magnitude: 2.24f), ctx); var trainer = new Trainer(net.CollectParams(), new SGD(learning_rate: 0.02f)); var epoch = 10; var metric = new Accuracy(); var softmax_cross_entropy_loss = new SoftmaxCELoss(); float lossVal = 0; for (var iter = 0; iter < epoch; iter++) { var tic = DateTime.Now; train_data.Reset(); lossVal = 0; while (!train_data.End()) { var batch = train_data.Next(); var data = Utils.SplitAndLoad(batch.Data[0], ctx, batch_axis: 0); var label = Utils.SplitAndLoad(batch.Label[0], ctx, batch_axis: 0); var outputs = new NDArrayList(); using (var ag = Autograd.Record()) { for (var i = 0; i < data.Length; i++) { var x = data[i]; var y = label[i]; var z = net.Call(x); NDArray loss = softmax_cross_entropy_loss.Call(z, y); loss.Backward(); lossVal += loss.Mean(); outputs.Add(z); } //outputs = Enumerable.Zip(data, label, (x, y) => //{ // var z = net.Call(x); // NDArray loss = softmax_cross_entropy_loss.Call(z, y); // loss.Backward(); // lossVal += loss.Mean(); // return z; //}).ToList(); } metric.Update(label, outputs.ToArray()); trainer.Step(batch.Data[0].Shape[0]); } var toc = DateTime.Now; var(name, acc) = metric.Get(); metric.Reset(); Console.Write($"Loss: {lossVal} "); Console.WriteLine($"Training acc at epoch {iter}: {name}={(acc * 100).ToString("0.##")}%, Duration: {(toc - tic).TotalSeconds.ToString("0.#")}s"); } }
public static void LoadConfig(this Conv2D layer, KerasLayerConfigJson config) { layer.Filters = config.filters; layer.KernalSize = new Vector2Int(config.kernel_size[0], config.kernel_size[1]); layer.Stride = new Vector2Int(config.strides[0], config.strides[1]); }
public static void Run() { int batch_size = 128; int num_classes = 10; int epochs = 12; // input image dimensions int img_rows = 28, img_cols = 28; Shape input_shape = null; // the data, split between train and test sets var((x_train, y_train), (x_test, y_test)) = MNIST.LoadData(); if (K.ImageDataFormat() == "channels_first") { x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols); x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols); input_shape = (1, img_rows, img_cols); } else { x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1); x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1); input_shape = (img_rows, img_cols, 1); } x_train = x_train.astype(np.float32); x_test = x_test.astype(np.float32); x_train /= 255; x_test /= 255; Console.WriteLine("x_train shape: " + x_train.shape); Console.WriteLine(x_train.shape[0] + " train samples"); Console.WriteLine(x_test.shape[0] + " test samples"); // convert class vectors to binary class matrices y_train = Util.ToCategorical(y_train, num_classes); y_test = Util.ToCategorical(y_test, num_classes); // Build CNN model var model = new Sequential(); model.Add(new Conv2D(32, kernel_size: (3, 3).ToTuple(), activation: "relu", input_shape: input_shape)); model.Add(new Conv2D(64, (3, 3).ToTuple(), activation: "relu")); model.Add(new MaxPooling2D(pool_size: (2, 2).ToTuple())); model.Add(new Dropout(0.25)); model.Add(new Flatten()); model.Add(new Dense(128, activation: "relu")); model.Add(new Dropout(0.5)); model.Add(new Dense(num_classes, activation: "softmax")); model.Compile(loss: "categorical_crossentropy", optimizer: new Adadelta(), metrics: new string[] { "accuracy" }); model.Fit(x_train, y_train, batch_size: batch_size, epochs: epochs, verbose: 1, validation_data: new NDarray[] { x_test, y_test }); var score = model.Evaluate(x_test, y_test, verbose: 0); Console.WriteLine("Test loss:" + score[0]); Console.WriteLine("Test accuracy:" + score[1]); }
static void Main(string[] args) { int batch_size = 128; //Training batch size int num_classes = 10; //No. of classes int epochs = 12; //No. of epoches we will train // input image dimensions int img_rows = 28, img_cols = 28; // Declare the input shape for the network Shape input_shape = null; // Load the MNIST dataset into Numpy array var((x_train, y_train), (x_test, y_test)) = MNIST.LoadData(); //Check if its channel fist or last and rearrange the dataset accordingly if (K.ImageDataFormat() == "channels_first") { x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols); x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols); input_shape = (1, img_rows, img_cols); } else { x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1); x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1); input_shape = (img_rows, img_cols, 1); } //Normalize the input data x_train = x_train.astype(np.float32); x_test = x_test.astype(np.float32); x_train /= 255; x_test /= 255; Console.WriteLine("x_train shape: " + x_train.shape); Console.WriteLine(x_train.shape[0] + " train samples"); Console.WriteLine(x_test.shape[0] + " test samples"); // Convert class vectors to binary class matrices y_train = Util.ToCategorical(y_train, num_classes); y_test = Util.ToCategorical(y_test, num_classes); // Build CNN model var model = new Sequential(); model.Add(new Conv2D(32, kernel_size: (3, 3).ToTuple(), activation: "relu", input_shape: input_shape)); model.Add(new Conv2D(64, (3, 3).ToTuple(), activation: "relu")); model.Add(new MaxPooling2D(pool_size: (2, 2).ToTuple())); model.Add(new Dropout(0.25)); model.Add(new Flatten()); model.Add(new Dense(128, activation: "relu")); model.Add(new Dropout(0.5)); model.Add(new Dense(num_classes, activation: "softmax")); //Compile with loss, metrics and optimizer model.Compile(loss: "categorical_crossentropy", optimizer: new Adadelta(), metrics: new string[] { "accuracy" }); //Train the model model.Fit(x_train, y_train, batch_size: batch_size, epochs: epochs, verbose: 1, validation_data: new NDarray[] { x_test, y_test }); //Score the model for performance var score = model.Evaluate(x_test, y_test, verbose: 0); Console.WriteLine("Test loss:" + score[0]); Console.WriteLine("Test accuracy:" + score[1]); // Save the model to HDF5 format which can be loaded later or ported to other application model.Save("model.h5"); // Save it to Tensorflow JS format and we will test it in browser. var v = K.Instance; //model.SaveTensorflowJSFormat(@"C:\_temp\"); //model.SaveOnnx(@"C:\_temp\"); Console.ReadLine(); }
private static void LoadModel(KerasLayersJson layersJson, List <NNLayerBase> Layers) { foreach (var layer in layersJson.layers) { switch (layer.class_name) { case "InputLayer": var Input = new InputLayer(); Input.LoadConfig(layer.config); Layers.Add(Input); break; case "Activation": if (layer.config.activation == "relu") { Layers.Add(new ReLU()); } if (layer.config.activation == "tanh") { Layers.Add(new Tanh()); } break; case "Conv2D": var Conv2DLayer = new Conv2D(); Conv2DLayer.LoadConfig(layer.config); Layers.Add(Conv2DLayer); if (layer.config.activation == "relu") { Layers.Add(new ReLU()); } if (layer.config.activation == "tanh") { Layers.Add(new Tanh()); } break; case "LeakyReLU": var LeakyReLULayer = new LeakyReLU(); LeakyReLULayer.LoadConfig(layer.config); Layers.Add(LeakyReLULayer); break; case "BatchNormalization": Layers.Add(new BatchNormalization()); break; case "UpSampling2D": var UpSampling2DLayer = new UpSampling2D(); UpSampling2DLayer.LoadConfig(layer.config); Layers.Add(UpSampling2DLayer); break; case "Concatenate": var thislayer = new Concatenate(); string alternativeLayerName = layer.inbound_nodes[0][1][0] as string; thislayer.AlternativeInputId = Layers.FindIndex(ly => string.Compare(ly.Name, alternativeLayerName) == 0); Layers.Add(thislayer); break; case "Add": var addlayer = new Add(); int alterinput = layer.inbound_nodes[0].FindIndex(node => string.Compare(node[0] as string, Layers[Layers.Count - 1].Name) != 0); string addalternativeLayerName = layer.inbound_nodes[0][alterinput][0] as string; addlayer.AlternativeInputId = Layers.FindIndex(ly => string.Compare(ly.Name, addalternativeLayerName) == 0); Layers.Add(addlayer); break; } Layers[Layers.Count - 1].Name = layer.name; } }