Welcome to an exciting journey of building convolutional neural networks (CNN) with ConvNetSharp! This versatile library started as a C# port of ConvNetJS and allows you to define, train, and evaluate CNNs easily. In this tutorial, we will explore how to create a simple neural network step-by-step.

Getting Started

Before diving into creating a neural network, make sure you have the following prerequisites:

• ConvNetSharp library installed.
• CUDA version 10.0 installed on your machine. For instructions, check the NVIDIA website.
• cuDNN v7.6.4 installed for CUDA 10.0. You can find it on the NVIDIA website.

Once you have set everything up, it’s time to create a neural network!

Creating a Simple Neural Network

Let’s jump right into coding a minimal example of a 2-layer neural network:

using System;
using ConvNetSharp.Core;
using ConvNetSharp.Core.Layers.Double;
using ConvNetSharp.Core.Training.Double;
using ConvNetSharp.Volume;
using ConvNetSharp.Volume.Double;

namespace MinimalExample
{
    internal class Program
    {
        private static void Main()
        {
            // specifies a 2-layer neural network with one hidden layer of 20 neurons
            var net = new Net(); 
            
            // input layer declares size of input. here: 2-D data
            // ConvNetJS works on 3-Dimensional volumes (width, height, depth)
            net.AddLayer(new InputLayer(1, 1, 2)); 

            // declare 20 neurons
            net.AddLayer(new FullyConnLayer(20)); 

            // declare a ReLU (rectified linear unit non-linearity)
            net.AddLayer(new ReluLayer()); 

            // declare a fully connected layer that will be used by the softmax layer
            net.AddLayer(new FullyConnLayer(10)); 

            // declare the linear classifier on top of the previous hidden layer
            net.AddLayer(new SoftmaxLayer(10)); 
            
            // forward a random data point through the network
            var x = BuilderInstance.Volume.From(new[] { 0.3, -0.5 }, new Shape(2));
            var prob = net.Forward(x); 

            // prints the probability that x is class 0
            Console.WriteLine("probability that x is class 0: " + prob.Get(0)); 

            var trainer = new SgdTrainer(net) { LearningRate = 0.01, L2Decay = 0.001 };
            // train the network, specifying that x is class zero
            trainer.Train(x, BuilderInstance.Volume.From(new[] { 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 }, new Shape(1, 1, 10, 1))); 

            var prob2 = net.Forward(x); 
            // now prints a higher probability for class zero
            Console.WriteLine("probability that x is class 0: " + prob2.Get(0)); 
        }
    }
}

Understanding the Code: An Analogy

Think of building a neural network like constructing a multi-story building. Each layer of neurons can be seen as a floor in the building:

• The Input Layer is the foundation, where you decide the dimensions of what the building will hold (in this case, the input data).
• The Fully Connected Layers are like different floors that allow various interactions (neuron connections) to take place, bringing information from the input layer to the output layer.
• The ReLU Layer acts like maintaining a flow of traffic, allowing certain paths (signals) to flourish while shutting others down to boost efficiency.
• The final Softmax Layer represents the rooftop, giving an overview of what the building (network) has achieved—the classification probabilities.

Using the Fluent API

If you prefer a more intuitive way of building networks, ConvNetSharp offers a Fluent API. Here’s a quick example:

var net = FluentNet.Create(24, 24, 1)
                   .Conv(5, 5, 8).Stride(1).Pad(2)
                   .Relu()
                   .Pool(2, 2).Stride(2)
                   .Conv(5, 5, 16).Stride(1).Pad(2)
                   .Relu()
                   .Pool(3, 3).Stride(3)
                   .FullyConn(10)
                   .Softmax(10)
                   .Build();

Switching to GPU Mode

For those looking to leverage the power of GPU, the transition is easy. Just add the necessary GPU namespaces and builders at the start of your code. Remember, you need to have the proper CUDA and cuDNN installations to execute GPU operations smoothly.

Saving and Loading Networks

ConvNetSharp makes it simple to save and load your networks. Using serialization, you can store your network configurations and reload them for future use:

using ConvNetSharp.Core.Serialization;

// Serialize to json
var json = net.ToJson(); 

// Deserialize from json
Net deserialized = SerializationExtensions.FromJson(json);

Troubleshooting

If you encounter problems, here are some troubleshooting ideas:

• Ensure your CUDA and cuDNN versions are compatible with ConvNetSharp.
• Check that your network layers are added correctly without inconsistencies.
• Inspect the parameters for the learning rate and L2 decay; improper values might impede training.
• For any persistent issues, consult the community and resources available at fxis.ai.

For more insights, updates, or to collaborate on AI development projects, stay connected with fxis.ai.

Conclusion

With ConvNetSharp, building and training a neural network has never been easier! As you explore more complex networks, keep experimenting, and don’t hesitate to dive deep into resources to enhance your understanding.

At fxis.ai, we believe that such advancements are crucial for the future of AI, as they enable more comprehensive and effective solutions. Our team is continually exploring new methodologies to push the envelope in artificial intelligence, ensuring that our clients benefit from the latest technological innovations.