/// <summary>
/// Assess the fitted model on held out data.
/// </summary>
/// <param name="model">Fitted model</param>
/// <param name="data">All data</param>
/// <param name="isMissing">Which elements are missing (heldout)</param>
/// <param name="logTransform">Whether the data was log transformed</param>
/// <param name="means">The means used to normalise the data, if normalised</param>
/// <param name="vars">The variances used to normalise the data, if normalised</param>
/// <returns>Array of error measures</returns>
public static double[] AssessOnMissing(INetworkModel model, double[,] data, bool[,] isMissing, bool logTransform, double[] means = null, double[] vars = null)
{
double logProb = 0, error = 0, counter = 0;
for (int d = 0; d < data.GetLength(0); d++)
{
for (int n = 0; n < data.GetLength(1); n++)
{
if (isMissing[d, n])
{
counter += 1;
var prediction = GaussianOp.SampleAverageLogarithm(model.Marginal <Gaussian[, ]>("noiseLessY")[d, n], model.Marginal <Gamma[]>("noisePrecisionArray")[d]);
logProb += prediction.GetLogProb(data[d, n]);
double predMean = prediction.GetMean();
double dataPoint = data[d, n];
if (means != null)
{
predMean = predMean * Math.Sqrt(vars[d]) + means[d];
dataPoint = dataPoint * Math.Sqrt(vars[d]) + means[d];
}
if (logTransform)
{
predMean = Math.Exp(predMean);
dataPoint = Math.Exp(dataPoint);
}
error += Math.Abs(predMean - dataPoint);
}
}
}
logProb /= counter;
error /= counter;
return(new double[] { logProb, error });
}
/// <summary>
/// Get the predictive distribution for the N+1 time, used for the multivariate volatility experiments
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static VectorGaussian CorrelatedPredictions(INetworkModel model)
{
var noisePrecisionPost = model.Marginal <Gamma[]>("noisePrecisionArray");
var f = model.Marginal <Gaussian[][]>("nodeFunctionValuesPredictive");
var W = model.Marginal <Gaussian[, ][]>("weightFunctionValuesPredictive");
int ni = model.N - 1;
var mean = Vector.Zero(model.D);
var cov = new PositiveDefiniteMatrix(model.D, model.D);
for (int i = 0; i < model.D; i++)
{
cov[i, i] = noisePrecisionPost[i].GetMeanInverse();
for (int k = 0; k < model.Q; k++)
{
mean[i] += W[i, k][ni].GetMean() * f[k][ni].GetMean();
cov[i, i] += W[i, k][ni].GetVariance() * (f[k][ni].GetMean() * f[k][ni].GetMean() + f[k][ni].GetVariance());
}
for (int j = 0; j < model.D; j++)
{
for (int k = 0; k < model.Q; k++)
{
cov[i, j] += W[i, k][ni].GetMean() * W[j, k][ni].GetMean() * f[k][ni].GetVariance();
}
}
}
return(VectorGaussian.FromMeanAndVariance(mean, cov));
}
/// <summary>
/// Get the fitted NOISE covariance only over the time series
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static PositiveDefiniteMatrix[] HistoricalNoiseCovariances(INetworkModel model)
{
var noisePrecisionPost = model.Marginal <Gamma[]>("noisePrecisionArray");
var nodeSignalPrecisionsPost = model.Marginal <Gamma[]>("nodeSignalPrecisions");
var W = model.Marginal <Gaussian[, ][]>("weightFunctionValuesPredictive");
var result = new PositiveDefiniteMatrix[model.N];
for (int ni = 0; ni < model.N; ni++)
{
var cov = new PositiveDefiniteMatrix(model.D, model.D);
for (int i = 0; i < model.D; i++)
{
cov[i, i] = noisePrecisionPost[i].GetMeanInverse();
for (int j = 0; j < model.D; j++)
{
for (int k = 0; k < model.Q; k++)
{
cov[i, j] += W[i, k][ni].GetMean() * W[j, k][ni].GetMean() * nodeSignalPrecisionsPost[k].GetMeanInverse();
}
}
}
result[ni] = cov;
}
return(result);
}
public ServerActor(INetworkModel networkModel, string address) : base(networkModel)
{
Address = address;
Server = networkModel.CreateServer(address, false);
Server.MessageReceived += Server_MessageReceived;
Server.ClientConnected += Server_ClientConnected;
Server.ClientDisconnected += Server_ClientDisconnected;
}
public RaftClient(INetworkModel networkModel, string clientId) : base(networkModel)
{
this.Id = clientId;
Client = new NetworkClient(networkModel)
{
MaxConnectAttempts = -1
};
Client.ClientChannel.StateChanged += ClientChannel_StateChanged;
}
public NetworkClient(INetworkModel network, string address = null)
{
this.Network = network;
_Channel = network.CreateClientSocket(address);
reconnectTimer.Elapsed += reconnectTimer_Elapsed;
MaxConnectAttempts = 1;
}
void TestNetworkState(INetworkModel network)
{
InProcNetwork inProcNetwork = network as InProcNetwork;
if (inProcNetwork != null)
{
Check.That(inProcNetwork.TaskScheduler.Exceptions.Count).IsEqualTo(0);
}
}
public RaftHost(INetworkModel networkModel, IRaftEventListener raftEventListener, IRaftNodeSettings raftSettings, string Id) :
base(networkModel)
{
this.Id = Id;
if (Id == null)
{
throw new ArgumentException("Id");
}
Raft = new RaftNode <string>(raftEventListener, raftSettings, Id);
Server = networkModel.CreateServer(Id, startListening: false);
}
public void ClientRestartTest()
{
using (INetworkModel network = CreateNetworkModel())
{
// setup client and server actors
TestClientActor clientActor = new TestClientActor(network);
string serverAddress = "127.0.0.1:99";
TestServerActor serverActor = new TestServerActor(network, serverAddress);
clientActor.AddConnectionTo(serverAddress);
clientActor.Start();
serverActor.Start();
Wait(15);
Check.That(network.ConnectedSocketCount).IsEqualTo(2);
clientActor.Stop();
Wait(15);
Check.That(network.ConnectedSocketCount).IsEqualTo(0);
}
}
public void TestClientServerActor()
{
using (INetworkModel network = CreateNetworkModel())
{
// setup client and server actors
TestClientActor clientActor = new TestClientActor(network);
string serverAddress = "127.0.0.1:99";
TestServerActor serverActor = new TestServerActor(network, serverAddress);
clientActor.AddConnectionTo(serverAddress);
// client actor should not create any clients when not started
Check.That(clientActor.WorkingClientCount).IsEqualTo(0);
// start server and client actor
serverActor.Start();
clientActor.Start();
// wait for connection to be established
Wait(15);
Check.That(clientActor.WorkingClientCount).IsEqualTo(1);
Check.That(clientActor.NetworkClientContexts[0].NetworkClient.State).IsEqualTo(NetworkClientState.Connected);
Check.That(network.ConnectedSocketCount).IsEqualTo(2);
// add another connection to server
clientActor.AddConnectionTo(serverAddress);
Wait(15);
Check.That(network.ConnectedSocketCount).IsEqualTo(4);
Check.That(clientActor.WorkingClientCount).IsEqualTo(2);
Check.That(clientActor.NetworkClientContexts[0].NetworkClient.State).IsEqualTo(NetworkClientState.Connected);
Check.That(clientActor.NetworkClientContexts[1].NetworkClient.State).IsEqualTo(NetworkClientState.Connected);
// stop client actor
clientActor.Stop();
Wait(15);
}
}
public void ServerActorShutdownTest()
{
using (INetworkModel network = CreateNetworkModel())
{
string serverAddress = "127.0.0.1:99";
// setup client and server actors
TestClientActor clientActor1 = new TestClientActor(network);
TestClientActor clientActor2 = new TestClientActor(network);
TestServerActor serverActor = new TestServerActor(network, serverAddress);
clientActor1.AddConnectionTo(serverAddress);
clientActor2.AddConnectionTo(serverAddress);
clientActor1.Start();
clientActor2.Start();
serverActor.Start();
Wait(15);
Check.That(network.ConnectedSocketCount).IsEqualTo(4);
Check.That(clientActor1.WorkingClientCount).IsEqualTo(1);
Check.That(clientActor2.WorkingClientCount).IsEqualTo(1);
// stop server actor
serverActor.Stop();
Wait(15);
// no connected socket should be present in network mode now
Check.That(network.ConnectedSocketCount).IsEqualTo(0);
// clients should still have one working client each
Check.That(clientActor1.WorkingClientCount).IsEqualTo(1);
Check.That(clientActor2.WorkingClientCount).IsEqualTo(1);
Check.That(clientActor1.NetworkClientContexts[0].NetworkClient.State).IsEqualTo(NetworkClientState.Reconnecting);
Check.That(clientActor2.NetworkClientContexts[0].NetworkClient.State).IsEqualTo(NetworkClientState.Reconnecting);
}
}
public void TestActorEvents()
{
using (INetworkModel network = CreateNetworkModel())
{
string serverAddress = "127.0.0.1:777";
// setup client and server actors
TestClientActor clientActor1 = new TestClientActor(network);
clientActor1.AddConnectionTo(serverAddress);
TestServerActor serverActor = new TestServerActor(network, serverAddress);
List <ActorEventBase> serverActorEvents = new List <ActorEventBase>();
serverActor.ActorEvent += (sender, ev) =>
{
serverActorEvents.Add(ev);
};
// this starts clientActor event loop
clientActor1.Start();
// this starts serverActor event loop
serverActor.Start();
// wait for connections to be established
Wait(100);
Check.That(clientActor1.WorkingClientCount).IsEqualTo(1);
Check.That(serverActorEvents.Count).IsEqualTo(1);
Check.That(serverActorEvents[0]).IsInstanceOf <ChannelAddedEvent>();
}
}
public NetworkNode(string name, INetworkModel network)
{
this.Network = network;
this.Name = name;
Init();
}
public StartApp(INetworkService networkService, INetworkModel networkModel, IConfigService configService)
{
_networkService = networkService;
_networkModel = networkModel;
_configService = configService;
}
public ActorBase(INetworkModel networkModel)
{
this.NetworkModel = networkModel;
NetworkClientContexts = new List <ClientInfo>();
Channels = new List <ActorChannel>();
}
public TestClientActor(INetworkModel networkModel) : base(networkModel)
{
}
public RaftDiagramDefinition(RaftSoundPlayer raftEventListener, INetworkModel networkModel, SimulationSettings worldSettings)
{
this.raftEventListener = raftEventListener;
this.simulationSettings = worldSettings;
// brokers
AddModelFor <BrokerViewModel, DiagramNodeBroker>(
"Broker",
(p) => new BrokerViewModel(string.Format("Br{0}", brokerNo++))
{
Location = p
},
(vm) => new DiagramNodeBroker()
{
Location = vm.Location, Name = vm.Name
},
(m) => new BrokerViewModel(m.Name)
{
Location = m.Location
}
);
// clients
AddModelFor <ClientViewModel, DiagramNodeClient>(
"NetworkClient",
(p) =>
{
string cliendId = (clientNo++).ToString();
RaftClient raftClient = new RaftClient(networkModel, cliendId);
return(new ClientViewModel(raftClient)
{
Location = p
});
},
(vm) => new DiagramNodeClient()
{
Location = vm.Location, Name = vm.Name
},
(m) =>
{
RaftClient raftClient = new RaftClient(networkModel, m.Name);
return(new ClientViewModel(raftClient)
{
Location = m.Location
});
}
);
// servers
AddModelFor <ServerViewModel, DiagramNodeServer>(
"Server",
(p) =>
{
serverNo++;
string raftNodeId = serverNo.ToString();
RaftHost serverSoftware = new RaftHost(networkModel, raftEventListener, simulationSettings, raftNodeId);
//this looks nasty
return(new ServerViewModel(serverSoftware)
{
Location = p
});
},
(vm) => new DiagramNodeServer()
{
Location = vm.Location, Name = vm.Name
},
(m) =>
{
RaftHost serverSoftware = new RaftHost(networkModel, raftEventListener, simulationSettings, m.Name);
return(new ServerViewModel(serverSoftware)
{
Location = m.Location
});
}
);
}
public TestServerActor(INetworkModel networkModel, string address) : base(networkModel, address)
{
}
public JoinGameCommand(INetworkService networkService, INetworkModel networkModel)
{
_networkService = networkService;
_networkModel = networkModel;
}
public NodeSoftwareBase(INetworkModel networkModel)
{
Channels = new List <INetworkSocket>();
this.NetworkModel = networkModel;
}
