Пример #1
0
        /// <summary>
        /// Tries to deserialize the gray box random forest. This method is the counterpart of TryToSerializeGrayBoxRandomForest in <see cref="AlgorithmTuner{TTargetAlgorithm,TInstance,TResult}"/>.
        /// </summary>
        /// <param name="grayBoxRandomForest">The gray box random forest.</param>
        /// <returns>True, if successful.</returns>
        private bool TryToDeserializeGrayBoxRandomForest(out ClassificationForestModel grayBoxRandomForest)
        {
            try
            {
                var timer = Stopwatch.StartNew();
                using (var file = File.OpenRead(this._configuration.GrayBoxRandomForestFile.FullName))
                {
                    grayBoxRandomForest = new Hyperion.Serializer().Deserialize <ClassificationForestModel>(file);
                }

                timer.Stop();

                if (grayBoxRandomForest != null)
                {
                    LoggingHelper.WriteLine(
                        VerbosityLevel.Info,
                        $"The deserialization of the gray box random forest before generation {this._currentEvaluation.GenerationId} on evaluation actor with address {this.Self} took {timer.Elapsed.TotalSeconds} seconds.");
                    return(true);
                }

                LoggingHelper.WriteLine(
                    VerbosityLevel.Warn,
                    $"Cannot deserialize gray box random forest before generation {this._currentEvaluation.GenerationId} on evaluation actor with address {this.Self}, because it is null.");
                return(false);
            }
            catch (Exception exception)
            {
                LoggingHelper.WriteLine(
                    VerbosityLevel.Warn,
                    $"Cannot deserialize gray box random forest before generation {this._currentEvaluation.GenerationId} on evaluation actor with address {this.Self}, because: {exception.Message}");
                grayBoxRandomForest = null;
                return(false);
            }
        }
Пример #2
0
        public void CheckIfTreeCanBeDeserialized()
        {
            var root = new AndNode();

            root.AddChild(new ValueNode <int>("a", new IntegerDomain()));
            root.AddChild(new ValueNode <int>("b", new IntegerDomain()));
            var tree = new ParameterTree(root);

            var serializer = new Hyperion.Serializer();
            var treeStream = new MemoryStream();

            serializer.Serialize(tree, treeStream);
            var streamCopy   = new MemoryStream(treeStream.GetBuffer());
            var restoredTree = serializer.Deserialize <ParameterTree>(streamCopy);

            Assert.NotNull(restoredTree);

            var originalNodes = tree.GetParameters().ToList();
            var restoredNodes = restoredTree.GetParameters().ToList();

            Assert.Equal(originalNodes.Count, restoredNodes.Count);
            for (var i = 0; i < originalNodes.Count; i++)
            {
                var expectedNode = originalNodes[i];
                var restoredNode = restoredNodes[i];

                Assert.True(expectedNode.Identifier == restoredNode.Identifier, "Nodes were deserialized in wrong order.");
                Assert.Equal(expectedNode.Domain.DomainSize, restoredNode.Domain.DomainSize);
            }
        }
        public void SetupSerializeHyperion()
        {
            var options = new Hyperion.SerializerOptions(
                versionTolerance: true,
                preserveObjectReferences: true
                );

            _value      = GetValue();
            _serializer = new Hyperion.Serializer(options);
        }
Пример #4
0
        public void CanSerializeFieldInfo()
        {
            var fieldInfo  = typeof(Dummy).GetField("TestField");
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(fieldInfo, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <FieldInfo>(stream);
                Assert.Equal(fieldInfo, deserialized);
            }
        }
Пример #5
0
        public void CanSerializePropertyInfo()
        {
            var propertyInfo = typeof(Dummy).GetProperty("TestProperty");
            var serializer   = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(propertyInfo, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <PropertyInfo>(stream);
                Assert.Equal(propertyInfo, deserialized);
            }
        }
Пример #6
0
        public void CanSerializeMethodInfo()
        {
            var methodInfo = typeof(Dummy).GetMethod("Fact");
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(methodInfo, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <MethodInfo>(stream);
                Assert.Equal(methodInfo, deserialized);
            }
        }
Пример #7
0
        public void CanSerializeSymbolDocumentInfo()
        {
            var info       = Expression.SymbolDocument("testFile");
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(info, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <SymbolDocumentInfo>(stream);
                Assert.Equal(info.FileName, deserialized.FileName);
            }
        }
        public void SetupDeserializeHyperion()
        {
            var options = new Hyperion.SerializerOptions(
                versionTolerance: true,
                preserveObjectReferences: true
                );

            _serializer1 = new Hyperion.Serializer(options);
            var s = new MemoryStream();

            _serializer1.Serialize(GetValue(), s);
            _hyperionData = s.ToArray();
        }
Пример #9
0
        public void CanSerializeConstructorInfo()
        {
            var constructorInfo = typeof(Dummy).GetConstructor(new[] { typeof(string) });
            var serializer      = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(constructorInfo, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <ConstructorInfo>(stream);
                Assert.Equal(constructorInfo, deserialized);
            }
        }
Пример #10
0
        public void CanSerializeDefaultExpression()
        {
            var expr       = Expression.Default(typeof(int));
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(expr, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <DefaultExpression>(stream);
                Assert.Equal(expr.Type, deserialized.Type);
                Assert.Equal(expr.NodeType, deserialized.NodeType);
            }
        }
Пример #11
0
        public void CanSerializeLabelTarget()
        {
            var label      = Expression.Label(typeof(int), "testLabel");
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(label, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <LabelTarget>(stream);
                Assert.Equal(label.Name, deserialized.Name);
                Assert.Equal(label.Type, deserialized.Type);
            }
        }
Пример #12
0
        public void CanSerializeBinaryExpression()
        {
            var expr       = Expression.Add(Expression.Constant(1), Expression.Constant(2));
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(expr, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <BinaryExpression>(stream);
                Assert.Equal(expr.NodeType, deserialized.NodeType);
                Assert.Equal(expr.Method, deserialized.Method);
            }
        }
Пример #13
0
        public void CanSerializeCatchBlock()
        {
            var expr       = Expression.Catch(typeof(DummyException), Expression.Constant(2));
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(expr, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <CatchBlock>(stream);
                Assert.Equal(expr.Test, deserialized.Test);
                Assert.Equal(expr.Body.ConstantValue(), deserialized.Body.ConstantValue());
            }
        }
Пример #14
0
        public void CanSerializeTargetInvocationException()
        {
            var exc        = new TargetInvocationException(null);
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(exc, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <TargetInvocationException>(stream);
                Assert.Equal(exc.Message, deserialized.Message);
                Assert.Equal(exc.StackTrace, deserialized.StackTrace);
            }
        }
Пример #15
0
        public void CanSerializeConstantExpression()
        {
            var expr       = Expression.Constant(12);
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(expr, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <ConstantExpression>(stream);
                Assert.Equal(expr.NodeType, deserialized.NodeType);
                Assert.Equal(expr.Value, deserialized.Value);
                Assert.Equal(expr.Type, deserialized.Type);
            }
        }
Пример #16
0
        public void CanSerializeUnaryExpression()
        {
            var expr       = Expression.Decrement(Expression.Constant(1));
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(expr, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <UnaryExpression>(stream);
                Assert.Equal(expr.NodeType, deserialized.NodeType);
                Assert.Equal(expr.Type, deserialized.Type);
                Assert.Equal(expr.Method, deserialized.Method);
                Assert.Equal(expr.Operand.ConstantValue(), deserialized.Operand.ConstantValue());
            }
        }
Пример #17
0
        /// <summary>
        /// Reads a serialized status object from file.
        /// </summary>
        /// <param name="path">
        /// The file path.
        /// </param>
        /// <typeparam name="T">
        /// The type of the expected deserialized object.
        /// </typeparam>
        /// <returns>
        /// The deserialized status object.
        /// </returns>
        public static T ReadFromFile <T>(string path)
            where T : StatusBase
        {
            T status;

            lock (StatusFileLock)
            {
                using (var file = File.OpenRead(path))
                {
                    status =
                        new Hyperion.Serializer().Deserialize <T>(file);
                }
            }

            return(status);
        }
Пример #18
0
        public void CanSerializeMemberAssignment()
        {
            var property   = typeof(Dummy).GetProperty("TestProperty");
            var expr       = Expression.Bind(property.SetMethod, Expression.Constant(9));
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(expr, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <MemberAssignment>(stream);
                Assert.Equal(expr.BindingType, deserialized.BindingType);
                Assert.Equal(expr.Member, deserialized.Member);
                Assert.Equal(expr.Expression.ConstantValue(), deserialized.Expression.ConstantValue());
            }
        }
Пример #19
0
        public void CanSerializeElementInit()
        {
            var listAddMethod = typeof(List <int>).GetMethod("Add");
            var expr          = Expression.ElementInit(listAddMethod, Expression.Constant(1));
            var serializer    = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(expr, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <ElementInit>(stream);
                Assert.Equal(expr.AddMethod, deserialized.AddMethod);
                Assert.Equal(1, deserialized.Arguments.Count);
                Assert.Equal(expr.Arguments[0].ConstantValue(), deserialized.Arguments[0].ConstantValue());
            }
        }
Пример #20
0
        public void CanSerializeConditionalExpression()
        {
            var expr       = Expression.Condition(Expression.Constant(true), Expression.Constant(1), Expression.Constant(2));
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(expr, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <ConditionalExpression>(stream);
                Assert.Equal(expr.NodeType, deserialized.NodeType);
                Assert.Equal(expr.Type, deserialized.Type);
                Assert.Equal(expr.Test.ConstantValue(), deserialized.Test.ConstantValue());
                Assert.Equal(expr.IfTrue.ConstantValue(), deserialized.IfTrue.ConstantValue());
                Assert.Equal(expr.IfFalse.ConstantValue(), deserialized.IfFalse.ConstantValue());
            }
        }
Пример #21
0
        public void CanSerializeLabelExpression()
        {
            var label      = Expression.Label(typeof(int), "testLabel");
            var expr       = Expression.Label(label, Expression.Constant(2));
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(expr, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <LabelExpression>(stream);
                Assert.Equal(expr.Type, deserialized.Type);
                Assert.Equal(expr.NodeType, deserialized.NodeType);
                Assert.Equal(expr.Target.Name, deserialized.Target.Name);
                Assert.Equal(expr.DefaultValue.ConstantValue(), deserialized.DefaultValue.ConstantValue());
            }
        }
Пример #22
0
        public void CanSerializeObjectDisposedException()
        {
            var exc        = new ObjectDisposedException("Object is already disposed", new ArgumentException("One level deeper"));
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(exc, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <ObjectDisposedException>(stream);
                Assert.Equal(exc.Message, deserialized.Message);
                Assert.Equal(exc.StackTrace, deserialized.StackTrace);
                Assert.Equal(exc.InnerException.GetType(), deserialized.InnerException.GetType());
                Assert.Equal(exc.InnerException.Message, deserialized.InnerException.Message);
                Assert.Equal(exc.InnerException.StackTrace, deserialized.InnerException.StackTrace);
            }
        }
Пример #23
0
        public void CanSerializeGotoExpression()
        {
            var label      = Expression.Label(typeof(void), "testLabel");
            var expr       = Expression.Continue(label);
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(expr, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <GotoExpression>(stream);
                Assert.Equal(expr.NodeType, deserialized.NodeType);
                Assert.Equal(expr.Type, deserialized.Type);
                Assert.Equal(expr.Kind, deserialized.Kind);
                Assert.Equal(expr.Target.Name, deserialized.Target.Name);
            }
        }
Пример #24
0
        public void CanSerializeNewExpression()
        {
            var ctor       = typeof(Dummy).GetConstructor(new[] { typeof(string) });
            var expr       = Expression.New(ctor, Expression.Constant("test param"));
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(expr, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <NewExpression>(stream);
                Assert.Equal(expr.NodeType, deserialized.NodeType);
                Assert.Equal(expr.Type, deserialized.Type);
                Assert.Equal(expr.Constructor, deserialized.Constructor);
                Assert.Equal(expr.Arguments.Count, deserialized.Arguments.Count);
                Assert.Equal(expr.Arguments[0].ConstantValue(), deserialized.Arguments[0].ConstantValue());
            }
        }
Пример #25
0
        public void CanSerializeBlockExpression()
        {
            var expr       = Expression.Block(new[] { Expression.Constant(1), Expression.Constant(2), Expression.Constant(3) });
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(expr, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <BlockExpression>(stream);
                Assert.Equal(expr.NodeType, deserialized.NodeType);
                Assert.Equal(expr.Type, deserialized.Type);
                Assert.Equal(expr.Expressions.Count, deserialized.Expressions.Count);
                Assert.Equal(expr.Expressions[0].ConstantValue(), deserialized.Expressions[0].ConstantValue());
                Assert.Equal(expr.Expressions[1].ConstantValue(), deserialized.Expressions[1].ConstantValue());
                Assert.Equal(expr.Result.ConstantValue(), deserialized.Result.ConstantValue());
            }
        }
Пример #26
0
        public void CanSerializeLoopExpression()
        {
            var breakLabel    = Expression.Label(typeof(void), "break");
            var continueLabel = Expression.Label(typeof(void), "cont");
            var expr          = Expression.Loop(Expression.Constant(2), breakLabel, continueLabel);
            var serializer    = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(expr, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <LoopExpression>(stream);
                Assert.Equal(expr.NodeType, deserialized.NodeType);
                Assert.Equal(expr.Type, deserialized.Type);
                Assert.Equal(expr.Body.ConstantValue(), deserialized.Body.ConstantValue());
                Assert.Equal(expr.BreakLabel.Name, deserialized.BreakLabel.Name);
                Assert.Equal(expr.ContinueLabel.Name, deserialized.ContinueLabel.Name);
            }
        }
Пример #27
0
        public void CanSerializeMethodCallExpression()
        {
            var methodInfo = typeof(Dummy).GetMethod("Fact");
            var expr       = Expression.Call(Expression.Constant(new Dummy()), methodInfo, Expression.Constant("test string"));
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(expr, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <MethodCallExpression>(stream);
                Assert.Equal(expr.Type, deserialized.Type);
                Assert.Equal(expr.NodeType, deserialized.NodeType);
                Assert.Equal(expr.Method, deserialized.Method);
                Assert.Equal(expr.Object.ConstantValue(), deserialized.Object.ConstantValue());
                Assert.Equal(1, deserialized.Arguments.Count);
                Assert.Equal(expr.Arguments[0].ConstantValue(), deserialized.Arguments[0].ConstantValue());
            }
        }
Пример #28
0
        public void CanSerializeInvocationExpression()
        {
            var methodInfo = typeof(Dummy).GetMethod("Fact");
            var param      = Expression.Parameter(typeof(Dummy), "dummy");
            var lambda     = Expression.Lambda(Expression.Call(param, methodInfo, Expression.Constant("s")), param);
            var expr       = Expression.Invoke(lambda, Expression.Constant(new Dummy()));
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(expr, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <InvocationExpression>(stream);
                Assert.Equal(expr.NodeType, deserialized.NodeType);
                Assert.Equal(expr.Type, deserialized.Type);
                Assert.Equal(expr.Arguments.Count, deserialized.Arguments.Count);
                Assert.Equal(expr.Arguments[0].ConstantValue(), deserialized.Arguments[0].ConstantValue());
            }
        }
Пример #29
0
        public void CanSerializeDebugInfoExpression()
        {
            var info       = Expression.SymbolDocument("testFile");
            var expr       = Expression.DebugInfo(info, 1, 2, 3, 4);
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(expr, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <DebugInfoExpression>(stream);
                Assert.Equal(expr.NodeType, deserialized.NodeType);
                Assert.Equal(expr.Type, deserialized.Type);
                Assert.Equal(expr.Document.FileName, deserialized.Document.FileName);
                Assert.Equal(expr.EndColumn, deserialized.EndColumn);
                Assert.Equal(expr.StartColumn, deserialized.StartColumn);
                Assert.Equal(expr.EndLine, deserialized.EndLine);
                Assert.Equal(expr.StartLine, deserialized.StartLine);
            }
        }
Пример #30
0
        public void CanSerializeLambdaExpression()
        {
            var methodInfo = typeof(Dummy).GetMethod("Fact");
            var param      = Expression.Parameter(typeof(Dummy), "dummy");
            var expr       = Expression.Lambda(Expression.Call(param, methodInfo, Expression.Constant("s")), param);
            var serializer = new Hyperion.Serializer();

            using (var stream = new MemoryStream())
            {
                serializer.Serialize(expr, stream);
                stream.Position = 0;
                var deserialized = serializer.Deserialize <LambdaExpression>(stream);
                Assert.Equal(expr.NodeType, deserialized.NodeType);
                Assert.Equal(expr.Type, deserialized.Type);
                Assert.Equal(expr.Name, deserialized.Name);
                Assert.Equal(expr.TailCall, deserialized.TailCall);
                Assert.Equal(expr.ReturnType, deserialized.ReturnType);
                Assert.Equal(expr.Parameters.Count, deserialized.Parameters.Count);
                Assert.Equal(expr.Parameters[0].Name, deserialized.Parameters[0].Name);
            }
        }