Merge pull request #32 from roberino/networkspec

Networkspec

Author: roberino

build.sh

@@ -1,3 +1,5 @@
 #!/bin/sh
 dotnet restore "LinqInfer.sln"
-dotnet build "LinqInfer.sln"
+dotnet build "LinqInfer.sln"
+dotnet pack "src\LinqInfer\LinqInfer.csproj" --output ..\..\artifacts
+dotnet pack "src\LinqInfer.Microservices\LinqInfer.Microservices.csproj" --output ..\..\artifacts

src/LinqInfer/Data/BinaryVectorDocument.cs

@@ -14,7 +14,7 @@ namespace LinqInfer.Data
     /// General purpose document for serialising vector and general object data.
     /// The document supports serialising as XML and to a binary stream
     /// </summary>
-    public class BinaryVectorDocument : IBinaryPersistable, IXmlExportable, IXmlImportable
+    public class BinaryVectorDocument : IBinaryPersistable, IXmlExportable, IXmlImportable, IEquatable<BinaryVectorDocument>
     {
         private const string PropertiesName = "PROP";
         private const string BlobName = "BLOB";
@@ -102,8 +102,22 @@ public long Checksum
         {
             var type = instance?.GetType() ?? typeof(T);
 
-            Properties["AssemblyQualifiedName"] = type.AssemblyQualifiedName;
-            Properties["TypeName"] = type.Name;
+            SetType(type);
+        }
+
+        internal void SetType(Type type)
+        {
+            Properties[nameof(AssemblyQualifiedName)] = type.AssemblyQualifiedName;
+            Properties[nameof(TypeName)] = type.Name;
+        }
+
+        internal string AssemblyQualifiedName => PropertyOrDefault(nameof(AssemblyQualifiedName), string.Empty);
+
+        internal string TypeName => PropertyOrDefault(nameof(TypeName), string.Empty);
+
+        public BinaryVectorDocument FindChild<T>()
+        {
+            return QueryChildren(new { AssemblyQualifiedName = typeof(T).AssemblyQualifiedName }).FirstOrDefault();
         }
 
         public IDictionary<string, string> Properties
@@ -122,6 +136,29 @@ public IDictionary<string, byte[]> Blobs
             }
         }
 
+        public IEnumerable<BinaryVectorDocument> QueryChildren(object propertyQuery)
+        {
+            var query = propertyQuery.ToDictionary();
+
+            return Children.Where(c =>
+            {
+                bool found = true;
+
+                foreach (var q in query)
+                {
+                    if (c.Properties.TryGetValue(q.Key, out string v) && v == q.Value?.ToString())
+                    {
+                        continue;
+                    }
+
+                    found = false;
+                    break;
+                }
+
+                return found;
+            });
+        }
+
         public bool HasProperty(string name)
         {
             return _properties.ContainsKey(name);
@@ -212,12 +249,20 @@ internal T PropertyOrDefault<T>(Expression<Func<object>> keyExpression, T defaul
             return PropertyOrDefault(propName, defaultValue);
         }
 
-        internal void SetPropertyFromExpression(Expression<Func<object>> expression)
+        internal void SetPropertyFromExpression(Expression<Func<object>> expression, object value = null)
         {
             var propName = LinqExtensions.GetPropertyName(expression);
-            var value = expression.Compile().Invoke();
 
-            if (value != null)
+            if (value == null)
+            {
+                value = expression.Compile().Invoke();
+
+                if (value != null)
+                {
+                    Properties[propName] = value.ToString();
+                }
+            }
+            else
             {
                 Properties[propName] = value.ToString();
             }
@@ -227,7 +272,7 @@ internal BinaryVectorDocument GetChildDoc<T>(Type type = null, int? index = null
         {
             var tname = (type ?? typeof(T)).GetTypeInf().Name;
 
-            var childNode = index.HasValue ? Children[index.Value] : Children.SingleOrDefault(c => c.HasProperty("TypeName") && c.Properties["TypeName"] == tname);
+            var childNode = index.HasValue ? Children[index.Value] : Children.SingleOrDefault(c => c.TypeName == tname);
 
             if (childNode == null && !ignoreIfMissing) throw new FormatException("Child object not found : " + tname);
 
@@ -259,22 +304,23 @@ internal T ReadChildObject<T>(T obj, int? index = null, bool ignoreIfMissing = f
             throw new NotSupportedException();
         }
 
-        internal void WriteChildObject(object obj)
+        internal void WriteChildObject(object obj, object attributes = null)
         {
             if (obj == null) return;
 
-            var childType = obj.GetType().GetTypeInf();
-            var tc = Type.GetTypeCode(obj.GetType());
+            var childType = obj.GetType();
+            var tc = Type.GetTypeCode(childType);
 
             if (tc == TypeCode.Object)
             {
-                if (obj is IExportableAsVectorDocument && obj is IImportableAsVectorDocument)
+                if (obj is IExportableAsVectorDocument)
                 {
                     var childDoc = ((IExportableAsVectorDocument)obj).ToVectorDocument();
 
-                    childDoc.Properties["TypeName"] = childType.Name;
-                    childDoc.Properties["QualifiedTypeName"] = childType.AssemblyQualifiedName;
+                    SetProperties(childDoc, attributes);
 
+                    childDoc.SetType(childType);
+                    
                     Children.Add(childDoc);
                 }
                 else
@@ -283,8 +329,8 @@ internal void WriteChildObject(object obj)
                     {
                         var childDoc = new BinaryVectorDocument();
 
-                        childDoc.Properties["TypeName"] = childType.Name;
-                        childDoc.Properties["QualifiedTypeName"] = childType.AssemblyQualifiedName;
+                        SetProperties(childDoc, attributes);
+                        childDoc.SetType(childType);                        
                         childDoc.Properties["Data"] = ((IBinaryPersistable)obj).ToClob();
 
                         Children.Add(childDoc);
@@ -354,6 +400,19 @@ protected void Read(BinaryReader reader, int level)
             }
         }
 
+        private void SetProperties(BinaryVectorDocument doc, object obj)
+        {
+            if (obj != null)
+            {
+                var data = obj.ToDictionary();
+
+                foreach (var item in data)
+                {
+                    doc.Properties[item.Key] = item.Value.ToString();
+                }
+            }
+        }
+
         private XDocument ExportAsXml(bool isRoot, bool base64v)
         {
             var date = DateTime.UtcNow;
@@ -518,5 +577,30 @@ protected void Write(BinaryWriter writer, int level)
                 child.Write(writer, level + 1);
             }
         }
+
+        public bool Equals(BinaryVectorDocument other)
+        {
+            if (other == null) return false;
+            if (ReferenceEquals(this, other)) return true;
+            if (Checksum != other.Checksum) return false;
+
+            var xml1 = ExportAsXml();
+            var xml2 = other.ExportAsXml();
+
+            xml1.Root.Attribute("exported").Remove();
+            xml2.Root.Attribute("exported").Remove();
+
+            return string.Equals(xml1.ToString(), xml2.ToString());
+        }
+
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as BinaryVectorDocument);
+        }
+
+        public override int GetHashCode()
+        {
+            return ExportAsXml().ToString().GetHashCode();
+        }
     }
 }

src/LinqInfer/Learning/Classification/IClassifierTrainer.cs

@@ -0,0 +1,22 @@
+namespace LinqInfer.Learning.Classification
+{
+    public interface IClassifierTrainer : IAssistedLearningProcessor
+    {
+        /// <summary>
+        /// Removes inputs from the classifier. 
+        /// Subsequent training and classification should also
+        /// comply with the new input size.
+        /// </summary>
+        void PruneInputs(params int[] inputIndexes);
+
+        /// <summary>
+        /// Resets the error back to null
+        /// </summary>
+        void ResetError();
+
+        /// <summary>
+        /// Gets the classifier
+        /// </summary>
+        IVectorClassifier Output { get; }
+    }
+}

src/LinqInfer/Learning/Classification/IClassifierTrainingContext.cs

@@ -7,7 +7,36 @@ namespace LinqInfer.Learning.Classification
     /// for training a classifier.
     /// </summary>
     /// <typeparam name="TParameters">The parameters used to create the classifier</typeparam>
-    public interface IClassifierTrainingContext<TParameters> : IRawClassifierTrainingContext<TParameters>, ICloneableObject<IClassifierTrainingContext<TParameters>>
+    public interface IClassifierTrainingContext<TParameters> : IClassifierTrainer, ICloneableObject<IClassifierTrainingContext<TParameters>>
     {
+        /// <summary>
+        /// Gets a localised id for the training context
+        /// </summary>
+        int Id { get; }
+
+        /// <summary>
+        /// A counter that can be incremented to track iterations for this context
+        /// </summary>
+        int IterationCounter { get; set; }
+
+        /// <summary>
+        /// Returns the parameters used by this training instance
+        /// </summary>
+        TParameters Parameters { get; }
+
+        /// <summary>
+        /// Returns the current rate of error change.
+        /// </summary>
+        double? RateOfErrorChange { get; }
+
+        /// <summary>
+        /// Returns the error accumulated from training
+        /// </summary>
+        double? CumulativeError { get; }
+
+        /// <summary>
+        /// Returns the average error from training
+        /// </summary>
+        double? AverageError { get; }
     }
 }