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