Deserialization code refactoring

Author: Sergio0694

NeuralNetwork.NET/APIs/CuDnnNetworkLayersDeserializer.cs

@@ -0,0 +1,11 @@
+namespace NeuralNetworkNET.APIs.Enums
+{
+    /// <summary>
+    /// Indicates the preferred type of network layers to serialize, whenever possible
+    /// </summary>
+    public enum LayersLoadingPreference
+    {
+        Cpu,
+        Cuda
+    }
+}

NeuralNetwork.NET/APIs/Delegates/LayerDeserializer.cs

@@ -2,11 +2,10 @@
 using System.Collections.Generic;
 using System.IO;
 using System.IO.Compression;
-using System.Linq;
 using JetBrains.Annotations;
-using NeuralNetworkNET.APIs.Delegates;
 using NeuralNetworkNET.APIs.Interfaces;
 using NeuralNetworkNET.APIs.Enums;
+using NeuralNetworkNET.Cuda.Layers;
 using NeuralNetworkNET.Extensions;
 using NeuralNetworkNET.Networks.Implementations;
 using NeuralNetworkNET.Networks.Implementations.Layers;
@@ -27,43 +26,37 @@ public static class NeuralNetworkLoader
         /// Tries to deserialize a network from the input file
         /// </summary>
         /// <param name="file">The <see cref="FileInfo"/> instance for the file to load</param>
+        /// <param name="preference">The layers deserialization preference</param>
         /// <returns>The deserialized network, or null if the operation fails</returns>
         [PublicAPI]
         [Pure, CanBeNull]
-        public static INeuralNetwork TryLoad([NotNull] FileInfo file)
+        public static INeuralNetwork TryLoad([NotNull] FileInfo file, LayersLoadingPreference preference)
         {
             using (FileStream stream = file.OpenRead())
-                return TryLoad(stream);
+                return TryLoad(stream, preference);
         }
 
         /// <summary>
         /// Tries to deserialize a network from the input <see cref="Stream"/>
         /// </summary>
         /// <param name="stream">The <see cref="Stream"/> instance for the network to load</param>
-        /// <param name="deserializers">The list of deserializers to use to load the input network</param>
+        /// <param name="preference">The layers deserialization preference</param>
         /// <returns>The deserialized network, or null if the operation fails</returns>
         [PublicAPI]
         [Pure, CanBeNull]
-        public static INeuralNetwork TryLoad([NotNull] Stream stream, params LayerDeserializer[] deserializers)
+        public static INeuralNetwork TryLoad([NotNull] Stream stream, LayersLoadingPreference preference)
         {
-            if (deserializers.GroupBy(f => f).Any(g => g.Count() > 1)) throw new ArgumentException("The deserializers list can't contain duplicate entries", nameof(deserializers));
             try
             {
                 List<INetworkLayer> layers = new List<INetworkLayer>();
                 using (GZipStream gzip = new GZipStream(stream, CompressionMode.Decompress))
                 {
                     while (gzip.TryRead(out LayerType type))
                     {
-                        // Process the deserializers in precedence order
+                        // Deserialization attempt
                         INetworkLayer layer = null;
-                        foreach (LayerDeserializer deserializer in deserializers)
-                        {
-                            layer = deserializer(gzip, type);
-                            if (layer != null) break;
-                        }
-
-                        // Fallback
-                        if (layer == null) layer = DefaultLayersDeserializer(gzip, type);
+                        if (preference == LayersLoadingPreference.Cuda) layer = CudaDeserialize(gzip, type);
+                        if (layer == null) layer = CpuDeserialize(gzip, type);
                         if (layer == null) return null;
 
                         // Add to the queue
@@ -81,9 +74,11 @@ public static INeuralNetwork TryLoad([NotNull] Stream stream, params LayerDeseri
             }
         }
 
+        #region Deserializers
+
         // Default layers deserializer
         [MustUseReturnValue, CanBeNull]
-        private static INetworkLayer DefaultLayersDeserializer([NotNull] Stream stream, LayerType type)
+        private static INetworkLayer CpuDeserialize([NotNull] Stream stream, LayerType type)
         {
             switch (type)
             {
@@ -95,5 +90,22 @@ private static INetworkLayer DefaultLayersDeserializer([NotNull] Stream stream,
                 default: throw new ArgumentOutOfRangeException(nameof(type), $"The {type} layer type is not supported by the default deserializer");
             }
         }
+
+        // Cuda layers deserializer
+        [MustUseReturnValue, CanBeNull]
+        private static INetworkLayer CudaDeserialize([NotNull] Stream stream, LayerType type)
+        {
+            switch (type)
+            {
+                case LayerType.FullyConnected: return CuDnnFullyConnectedLayer.Deserialize(stream);
+                case LayerType.Convolutional: return CuDnnConvolutionalLayer.Deserialize(stream);
+                case LayerType.Pooling: return CuDnnPoolingLayer.Deserialize(stream);
+                case LayerType.Softmax: return CuDnnSoftmaxLayer.Deserialize(stream);
+                case LayerType.Inception: return CuDnnInceptionLayer.Deserialize(stream);
+                default: return null;
+            }
+        }
+        
+        #endregion
     }
 }

NeuralNetwork.NET/APIs/Enums/LayersLoadingPreference.cs

@@ -32,7 +32,7 @@ public void NetworkSerialization()
             {
                 network.Save(stream);
                 stream.Seek(0, SeekOrigin.Begin);
-                INeuralNetwork copy = NeuralNetworkLoader.TryLoad(stream, CuDnnNetworkLayersDeserializer.Deserializer);
+                INeuralNetwork copy = NeuralNetworkLoader.TryLoad(stream, LayersLoadingPreference.Cuda);
                 Assert.IsTrue(network.Equals(copy));
             }
         }

NeuralNetwork.NET/APIs/NeuralNetworkLoader.cs

@@ -73,7 +73,7 @@ public void NetworkSerialization()
             {
                 network.Save(stream);
                 stream.Seek(0, SeekOrigin.Begin);
-                INeuralNetwork copy = NeuralNetworkLoader.TryLoad(stream);
+                INeuralNetwork copy = NeuralNetworkLoader.TryLoad(stream, LayersLoadingPreference.Cpu);
                 Assert.IsTrue(network.Equals(copy));
             }
         }