/// <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);
}
}
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);
}
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);
}
}
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);
}
}
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);
}
}
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();
}
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);
}
}
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);
}
}
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);
}
}
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);
}
}
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());
}
}
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);
}
}
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);
}
}
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());
}
}
/// <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);
}
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());
}
}
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());
}
}
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());
}
}
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());
}
}
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);
}
}
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);
}
}
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());
}
}
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());
}
}
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);
}
}
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());
}
}
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());
}
}
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);
}
}
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);
}
}
