def main():
# start agent network server
agentNetwork = AgentNetwork()
# init agents
gen_agent = agentNetwork.add_agent(agentType=DataStreamAgent)
trainer_agent = agentNetwork.add_agent(agentType=Trainer)
predictor_agent = agentNetwork.add_agent(agentType=Predictor)
evaluator_agent = agentNetwork.add_agent(agentType=Evaluator)
monitor_agent_1 = agentNetwork.add_agent(agentType=MonitorAgent)
monitor_agent_2 = agentNetwork.add_agent(agentType=MonitorAgent)
gen_agent.init_parameters(stream=SineGenerator(), pretrain_size=1000,
batch_size=1)
trainer_agent.init_parameters(ml_model=HoeffdingTree())
# connect agents : We can connect multiple agents to any particular agent
# However the agent needs to implement handling multiple input types
agentNetwork.bind_agents(gen_agent, trainer_agent)
agentNetwork.bind_agents(gen_agent, predictor_agent)
agentNetwork.bind_agents(trainer_agent, predictor_agent)
agentNetwork.bind_agents(predictor_agent, evaluator_agent)
agentNetwork.bind_agents(evaluator_agent, monitor_agent_1)
agentNetwork.bind_agents(predictor_agent, monitor_agent_2)
# set all agents states to "Running"
agentNetwork.set_running_state()
# allow for shutting down the network after execution
return agentNetwork
def demonstrate_generator_agent_use() -> AgentNetwork:
# Start agent network server.
agent_network = AgentNetwork()
# Initialize agents by adding them to the agent network.
default_sine_agent = agent_network.add_agent(name="Default Sine generator",
agentType=SineGeneratorAgent)
# Custom parameters of the specified agentType can either be handed over as **kwargs
# in the network instance's add_agent() method, or...
custom_sine_agent = agent_network.add_agent(
name="Custom Sine generator",
agentType=SineGeneratorAgent,
sfreq=75,
sine_freq=np.pi,
)
# ... in a separate call of the agent instance's init_parameters() method.
custom_sine_agent.init_parameters(amplitude=0.75, )
monitor_agent = agent_network.add_agent(
name="Showcase a default and a customized sine signal",
agentType=MonitorAgent)
# Interconnect agents by either way:
# 1) by agent network.bind_agents(source, target).
agent_network.bind_agents(default_sine_agent, monitor_agent)
# 2) by the agent.bind_output().
custom_sine_agent.bind_output(monitor_agent)
# Set all agents' states to "Running".
agent_network.set_running_state()
# Allow for shutting down the network after execution
return agent_network
def main():
# start agent network server
agentNetwork = AgentNetwork()
# init agents by adding into the agent network
gen_agent = agentNetwork.add_agent(agentType=TimeSineGeneratorAgent)
monitor_agent = agentNetwork.add_agent(agentType=MonitorAgent)
# provide custom parameters to the monitor agent
xname, yname = "Time", "Y"
monitor_agent.init_parameters(
custom_plot_function=custom_create_monitor_graph,
xname=xname,
yname=yname,
noise_level=0.1,
)
# bind agents
agentNetwork.bind_agents(gen_agent, monitor_agent)
# set all agents states to "Running"
agentNetwork.set_running_state()
# allow for shutting down the network after execution
return agentNetwork
def test_simpleAgent(agentType, expected_monitor_results):
#start agent network server
agentNetwork = AgentNetwork(dashboard_modules=False)
#init agents by adding into the agent network
simple_agent = agentNetwork.add_agent(agentType=agentType)
monitor_agent_1 = agentNetwork.add_agent(agentType=MonitorAgent)
#shorten n wait loop time
simple_agent.init_agent_loop(0.01)
#connect agents
agentNetwork.bind_agents(simple_agent, monitor_agent_1)
# set all agents states to "Running"
agentNetwork.set_running_state()
time.sleep(test_timeout)
# test to see if monitor agents have received the correct data
assert str(
monitor_agent_1.get_attr('memory')) == str(expected_monitor_results)
# shutdown agent network
agentNetwork.shutdown()
time.sleep(3)
def test_remove_agent():
#start agent network server
agentNetwork = AgentNetwork(dashboard_modules=False)
#init agents by adding into the agent network
dummy_agent1 = agentNetwork.add_agent(agentType= AgentMET4FOF)
dummy_agent2 = agentNetwork.add_agent(agentType= AgentMET4FOF)
dummy_agent3 = agentNetwork.add_agent(agentType= AgentMET4FOF)
dummy_agent4 = agentNetwork.add_agent(agentType= AgentMET4FOF)
agentNetwork.bind_agents(dummy_agent1, dummy_agent2)
agentNetwork.bind_agents(dummy_agent1, dummy_agent3)
agentNetwork.bind_agents(dummy_agent1, dummy_agent4)
agentNetwork.bind_agents(dummy_agent4, dummy_agent2)
agentNetwork.bind_agents(dummy_agent3, dummy_agent4)
agentNetwork.bind_agents(dummy_agent2, dummy_agent4)
agentNetwork.remove_agent(dummy_agent1)
agentNetwork.remove_agent(dummy_agent2)
agentNetwork.remove_agent(dummy_agent3)
agentNetwork.remove_agent(dummy_agent4)
time.sleep(2)
assert len(agentNetwork.agents()) == 0
agentNetwork.shutdown()
def main():
# start agent network server
agentNetwork = AgentNetwork()
# init agents
sub_agent = agentNetwork.add_agent(agentType=SubtractAgent)
add_agent = agentNetwork.add_agent(agentType=AdditionAgent)
monitor_agent = agentNetwork.add_agent(agentType=MonitorAgent)
# connect
agentNetwork.bind_agents(sub_agent, monitor_agent)
agentNetwork.bind_agents(add_agent, monitor_agent)
# set all agents states to "Running"
agentNetwork.set_running_state()
# allow for shutting down the network after execution
return agentNetwork
def test_send_plot():
# start agent network server
agentNetwork = AgentNetwork(dashboard_modules=False)
# init agents
gen_agent = agentNetwork.add_agent(agentType=GeneratorAgent)
monitor_agent = agentNetwork.add_agent(agentType=MonitorAgent)
agentNetwork.bind_agents(gen_agent, monitor_agent, channel="plot")
gen_agent.dummy_send_graph(mode="plotly")
time.sleep(3)
assert monitor_agent.get_attr("plots")["GeneratorAgent_1"]
agentNetwork.shutdown()
def test_send_plot():
# start agent network server
agentNetwork = AgentNetwork(dashboard_modules=False)
# init agents
gen_agent = agentNetwork.add_agent(agentType=GeneratorAgent)
monitor_agent = agentNetwork.add_agent(agentType=MonitorAgent)
agentNetwork.bind_agents(gen_agent, monitor_agent)
gen_agent.dummy_send_graph()
time.sleep(3)
assert monitor_agent.get_attr('plots')['GeneratorAgent_1']
agentNetwork.shutdown()
def demonstrate_generator_agent_use():
# Start agent network server.
agent_network = AgentNetwork()
# Initialize agents by adding them to the agent network.
# The buffer size is set during initialisation
gen_agent = agent_network.add_agent(
agentType=BufferSineGeneratorAgent, buffer_size=5
)
monitor_agent = agent_network.add_agent(agentType=MonitorAgent)
# bind agents
agent_network.bind_agents(gen_agent, monitor_agent)
# Set all agents' states to "Running".
agent_network.set_running_state()
# Allow for shutting down the network after execution
return agent_network
def main():
# start agent network server
agentNetwork = AgentNetwork()
# init agents
gen_agent = agentNetwork.add_agent(agentType=SineGeneratorAgent)
math_agent = agentNetwork.add_agent(agentType=MathAgent)
multi_math_agent = agentNetwork.add_agent(agentType=MultiMathAgent)
monitor_agent = agentNetwork.add_agent(agentType=MonitorAgent)
# connect agents : We can connect multiple agents to any particular agent
agentNetwork.bind_agents(gen_agent, math_agent)
agentNetwork.bind_agents(gen_agent, multi_math_agent)
# connect
agentNetwork.bind_agents(gen_agent, monitor_agent)
agentNetwork.bind_agents(math_agent, monitor_agent)
agentNetwork.bind_agents(multi_math_agent, monitor_agent)
# set all agents states to "Running"
agentNetwork.set_running_state()
# allow for shutting down the network after execution
return agentNetwork
def demonstrate_generator_agent_use():
# Start agent network server.
agent_network = AgentNetwork()
# Initialize agents by adding them to the agent network.
gen_agent = agent_network.add_agent(agentType=MultiGeneratorAgent)
monitor_agent = agent_network.add_agent(agentType=MonitorAgent)
# Interconnect agents by either way:
# 1) by agent network.bind_agents(source, target).
agent_network.bind_agents(gen_agent, monitor_agent)
# 2) by the agent.bind_output().
gen_agent.bind_output(monitor_agent)
# Set all agents' states to "Running".
agent_network.set_running_state()
# Allow for shutting down the network after execution
return agent_network
def main():
#start agent network server
log_file = False
agentNetwork = AgentNetwork(log_filename=log_file, dashboard_update_interval=1)
#init agents by adding into the agent network
sensor_agent = agentNetwork.add_agent(agentType = OpenSenecaAgent, buffer_size=1)
monitor_agent = agentNetwork.add_agent(agentType = MonitorAgent, buffer_size=100)
sensor_agent.init_parameters(port_name='/dev/ttyUSB0')
sensor_agent.init_agent_loop(loop_wait=1)
#connect the sensor agent to the monitor agent
agentNetwork.bind_agents(sensor_agent, monitor_agent)
# set all agents states to "Running"
agentNetwork.set_running_state()
# allow for shutting down the network after execution
return agentNetwork
def main():
#start agent network server
agentNetwork = AgentNetwork()
#init agents by adding into the agent network
gen_agent = agentNetwork.add_agent(agentType=SineGeneratorAgent)
monitor_agent = agentNetwork.add_agent(agentType=MonitorAgent)
#connect agents by either way:
# 1) by agent network.bind_agents(source,target)
agentNetwork.bind_agents(gen_agent, monitor_agent)
# 2) by the agent.bind_output()
gen_agent.bind_output(monitor_agent)
# set all agents states to "Running"
agentNetwork.set_running_state()
# allow for shutting down the network after execution
return agentNetwork
def demonstrate_generator_agent_use():
# Start agent network server.
agent_network = AgentNetwork()
# Initialize agents by adding them to the agent network.
gen_agent = agent_network.add_agent(agentType=SineGeneratorAgent)
gen_agent.init_parameters(nested_output=True, scaler=1.0)
gen_agent_2 = agent_network.add_agent(agentType=SineGeneratorAgent)
gen_agent_2.init_parameters(nested_output=False, scaler=2.0)
monitor_agent = agent_network.add_agent(agentType=MonitorAgent)
# Connect the agents
agent_network.bind_agents(gen_agent, monitor_agent)
agent_network.bind_agents(gen_agent_2, monitor_agent)
# Set all agents' states to "Running".
agent_network.set_running_state()
# Allow for shutting down the network after execution
return agent_network
def main():
# start agent network server
agentNetwork = AgentNetwork()
# init agents
gen_agent = agentNetwork.add_agent(agentType=MultiGeneratorAgent)
multi_math_agent = agentNetwork.add_agent(agentType=MultiOutputMathAgent)
monitor_agent = agentNetwork.add_agent(agentType=MonitorAgent)
# connect agents : We can connect multiple agents to any particular agent
# However the agent needs to implement handling multiple inputs
agentNetwork.bind_agents(gen_agent,
multi_math_agent,
channel=["sine", "cosine"])
agentNetwork.bind_agents(multi_math_agent, monitor_agent)
# set all agents states to "Running"
agentNetwork.set_running_state()
# allow for shutting down the network after execution
return agentNetwork
def main():
#start agent network server
agentNetwork = AgentNetwork()
#init agents by adding into the agent network
monitor_agent = agentNetwork.add_agent(agentType=MonitorAgent)
iiR_agent = agentNetwork.add_agent(agentType=iiRAgent)
agentNetwork.bind_agents(iiR_agent, monitor_agent)
iiR_agent.bind_output(monitor_agent)
# there will be len(genTypes) generator agents with the specified type in genTypes
# the first geerator agent (i.e., genAgents[0]) with signal type genTypes[0] will be connected to the filter
genTypes = [SineGeneratorAgent, RectGeneratorAgent, ShockGeneratorAgent]
genAgents = []
for i in range(len(genTypes)):
genAgents.append(agentNetwork.add_agent(agentType=genTypes[i]))
agentNetwork.bind_agents(genAgents[i], monitor_agent)
genAgents[i].bind_output(monitor_agent)
agentNetwork.bind_agents(genAgents[0], iiR_agent)
genAgents[0].bind_output(iiR_agent)
# set all agents states to "Running"
agentNetwork.set_running_state()
# allow for shutting down the network after execution
return agentNetwork
def demonstrate_generator_agent_use():
# Start agent network server.
agent_network = AgentNetwork()
# Initialize agents by adding them to the agent network.
gen_agent = agent_network.add_agent(agentType=NoisySineGeneratorAgent)
# the buffer size controls the window size of the moving average filter
fast_rolling_mean_agent = agent_network.add_agent(
agentType=RollingMeanAgent, buffer_size=5)
slow_rolling_mean_agent = agent_network.add_agent(
agentType=RollingMeanAgent, buffer_size=10)
monitor_agent = agent_network.add_agent(agentType=MonitorAgent)
# bind agents
agent_network.bind_agents(gen_agent, fast_rolling_mean_agent)
agent_network.bind_agents(gen_agent, slow_rolling_mean_agent)
agent_network.bind_agents(gen_agent, monitor_agent)
agent_network.bind_agents(fast_rolling_mean_agent, monitor_agent)
agent_network.bind_agents(slow_rolling_mean_agent, monitor_agent)
# Set all agents' states to "Running".
agent_network.set_running_state()
# Allow for shutting down the network after execution
return agent_network
def demonstrate_generator_agent_use():
# Start agent network server.
agent_network = AgentNetwork()
# Initialize agents by adding them to the agent network.
gen_agent_1 = agent_network.add_agent(agentType=SineGeneratorAgent)
gen_agent_2 = agent_network.add_agent(agentType=SineGeneratorAgent)
monitor_agent = agent_network.add_agent(agentType=MonitorAgent)
# bind generator agents outputs to monitor
agent_network.bind_agents(gen_agent_1, monitor_agent)
agent_network.bind_agents(gen_agent_2, monitor_agent)
# setup health coalition group
agent_network.add_coalition("REDUNDANT_SENSORS",
[gen_agent_1, gen_agent_2, monitor_agent])
# Set all agents' states to "Running".
agent_network.set_running_state()
# Allow for shutting down the network after execution
return agent_network
def demonstrate_generator_agent_use():
# Start agent network server.
agent_network = AgentNetwork()
# Initialize agents by adding them to the agent network.
gen_agent: AgentMET4FOF = agent_network.add_agent(
agentType=GaussianShockGeneratorAgent
)
# Here we apply the default settings we chose above.
gen_agent.init_parameters()
monitor_agent = agent_network.add_agent(agentType=MonitorAgent)
# Interconnect agents by either way:
# 1) by agent network.bind_agents(source, target).
agent_network.bind_agents(gen_agent, monitor_agent)
# 2) by the agent.bind_output().
gen_agent.bind_output(monitor_agent)
# Set all agents' states to "Running".
agent_network.set_running_state()
# Allow for shutting down the network after execution
return agent_network
def main():
#start agent network server
agentNetwork = AgentNetwork(dashboard_modules=[],
dashboard_update_interval=0.75,
log_filename='log_name.csv',
backend="mesa")
#init agents by adding into the agent network
gen_agent = agentNetwork.add_agent(agentType=SineGeneratorAgent,
buffer_size=1,
log_mode=False)
monitor_agent = agentNetwork.add_agent(agentType=MonitorAgent,
buffer_size=50,
log_mode=False)
monitor_agent_2 = agentNetwork.add_agent(agentType=MonitorAgent,
buffer_size=10,
log_mode=False)
gen_agent.init_agent_loop(loop_wait=1)
#This monitor agent will only store 'quantities' of the data keys into its memory
monitor_agent.init_parameters(plot_filter=['quantities'])
#connect agents by either way:
# 1) by agent network.bind_agents(source,target)
agentNetwork.bind_agents(gen_agent, monitor_agent)
# 2) by the agent.bind_output()
gen_agent.bind_output(monitor_agent)
gen_agent.bind_output(monitor_agent_2)
# set all agents states to "Running"
agentNetwork.set_running_state()
# allow for shutting down the network after execution
return agentNetwork
def main():
global agentNetwork
# start agent network
agentNetwork = AgentNetwork()
# add agents
data_stream_agent_1 = agentNetwork.add_agent(agentType=DataStreamAgent)
ml_agent_hoeffdingTree = agentNetwork.add_agent(agentType=ML_Model)
ml_agent_neuralNets = agentNetwork.add_agent(agentType=ML_Model)
monitor_agent_1 = agentNetwork.add_agent(agentType=MonitorAgent)
# init parameters
data_stream_agent_1.init_parameters(stream=WaveformGenerator(),
pretrain_size=1000,
batch_size=100)
ml_agent_hoeffdingTree.init_parameters(ml_model=HoeffdingTreeClassifier())
ml_agent_neuralNets.init_parameters(ml_model=NaiveBayes())
# connect agents
agentNetwork.bind_agents(data_stream_agent_1, ml_agent_hoeffdingTree)
agentNetwork.bind_agents(data_stream_agent_1, ml_agent_neuralNets)
agentNetwork.bind_agents(ml_agent_hoeffdingTree, monitor_agent_1)
agentNetwork.bind_agents(ml_agent_neuralNets, monitor_agent_1)
agentNetwork.set_running_state()
# allow for shutting down the network after execution
return agentNetwork
def main():
# start agent network server
agentNetwork = AgentNetwork()
# init agents
gen_agent = agentNetwork.add_agent(agentType=RandomGeneratorAgent)
plotting_image_agent = agentNetwork.add_agent(agentType=PlottingAgent,
name="Plot_image")
plotting_plotly_agent = agentNetwork.add_agent(agentType=PlottingAgent,
name="Plot_plotly")
plotting_mpld3_agent = agentNetwork.add_agent(agentType=PlottingAgent,
name="Plot_mpld3")
monitor_agent = agentNetwork.add_agent(agentType=MonitorAgent)
# init parameters
plotting_image_agent.init_parameters(plot_mode="image")
plotting_plotly_agent.init_parameters(plot_mode="plotly")
plotting_mpld3_agent.init_parameters(plot_mode="mpld3")
# bind agents
agentNetwork.bind_agents(gen_agent, plotting_image_agent)
agentNetwork.bind_agents(gen_agent, plotting_plotly_agent)
agentNetwork.bind_agents(gen_agent, plotting_mpld3_agent)
agentNetwork.bind_agents(plotting_image_agent, monitor_agent)
agentNetwork.bind_agents(plotting_plotly_agent, monitor_agent)
agentNetwork.bind_agents(plotting_mpld3_agent, monitor_agent)
# set all agents states to "Running"
agentNetwork.set_running_state()
# allow for shutting down the network after execution
return agentNetwork
def main():
# start agent network server
agentNetwork = AgentNetwork(
dashboard_modules=[zema_datastream,
zema_agents], log_filename=False, backend="mesa")
# init agents by adding into the agent network
datastream_agent = agentNetwork.add_agent(agentType=DataStreamAgent)
train_test_split_agent = agentNetwork.add_agent(
agentType=TrainTestSplitAgent)
fft_bfc_agent = agentNetwork.add_agent(agentType=FFT_BFCAgent)
pearson_fs_agent = agentNetwork.add_agent(
agentType=Pearson_FeatureSelectionAgent)
lda_agent = agentNetwork.add_agent(agentType=LDA_Agent)
bayesianRidge_agent = agentNetwork.add_agent(agentType=Regression_Agent,
name="BayesianRidge_Agent")
randomForest_agent = agentNetwork.add_agent(agentType=Regression_Agent,
name="RandomForest_Agent")
evaluator_agent = agentNetwork.add_agent(agentType=EvaluatorAgent)
monitor_agent = agentNetwork.add_agent(agentType=MonitorAgent)
# init parameters
# incremental training
datastream_agent.init_parameters(stream=ZEMA_DataStream(),
pretrain_size=1000, batch_size=250,
loop_wait=10, randomize=True)
# batch training
# datastream_agent.init_parameters(stream=ZEMA_DataStream(),
# pretrain_size=-1, randomize=True)
# hold-out or prequential mode
# train_test_split_agent.init_parameters(train_ratio=0.8) #hold-out
train_test_split_agent.init_parameters(train_ratio=-1) # prequential
# init parameters for base models
lda_agent.init_parameters()
bayesianRidge_agent.init_parameters(regression_model="BayesianRidge")
randomForest_agent.init_parameters(regression_model="RandomForest")
# bind agents
agentNetwork.bind_agents(datastream_agent, train_test_split_agent)
agentNetwork.bind_agents(train_test_split_agent, fft_bfc_agent)
agentNetwork.bind_agents(fft_bfc_agent, pearson_fs_agent)
agentNetwork.bind_agents(pearson_fs_agent, lda_agent)
agentNetwork.bind_agents(lda_agent, evaluator_agent)
agentNetwork.bind_agents(pearson_fs_agent, bayesianRidge_agent)
agentNetwork.bind_agents(bayesianRidge_agent, evaluator_agent)
agentNetwork.bind_agents(pearson_fs_agent, randomForest_agent)
agentNetwork.bind_agents(randomForest_agent, evaluator_agent)
# bind to monitor agents
agentNetwork.bind_agents(fft_bfc_agent, monitor_agent)
agentNetwork.bind_agents(pearson_fs_agent, monitor_agent)
agentNetwork.bind_agents(evaluator_agent, monitor_agent)
# set running state
agentNetwork.set_running_state()
# allow for shutting down the network after execution
return agentNetwork
class SineGeneratorAgent(AgentMET4FOF):
def init_parameters(self):
self.stream = SineGenerator()
def agent_loop(self):
if self.current_state == "Running":
sine_data = self.stream.next_sample() #dictionary
self.send_output(sine_data['x'])
if __name__ == '__main__':
#start agent network server
agentNetwork = AgentNetwork(dashboard_modules=False)
#init agents by adding into the agent network
gen_agent = agentNetwork.add_agent(agentType=SineGeneratorAgent)
_logger_agent = agentNetwork.add_agent(agentType=_Logger)
monitor_agent = agentNetwork.add_agent(agentType=MonitorAgent)
gen_agent.set_logger(_logger_agent)
#connect agents by either way:
# 1) by agent network.bind_agents(source,target)
agentNetwork.bind_agents(gen_agent, monitor_agent)
# 2) by the agent.bind_output()
gen_agent.bind_output(monitor_agent)
# set all agents states to "Running"
agentNetwork.set_running_state()
def run_detection():
# start agent network server
agentNetwork = AgentNetwork()
gen_agent_test1 = agentNetwork.add_agent(
name="Sensor1",
agentType=SineGeneratorAgent,
log_mode=False,
buffer_size=5,
)
gen_agent_test2 = agentNetwork.add_agent(
name="Sensor2",
agentType=SineGeneratorAgent,
log_mode=False,
buffer_size=5,
)
gen_agent_test3 = agentNetwork.add_agent(
name="Sensor3",
agentType=SineGeneratorAgent,
log_mode=False,
buffer_size=5,
)
aggregator_agent = agentNetwork.add_agent(agentType=Aggregator)
disturbance_agent = agentNetwork.add_agent(agentType=Disturbance)
Trainer_Predictor_agent = agentNetwork.add_agent(
agentType=Trainer_Predictor)
monitor_agent_1 = agentNetwork.add_agent(agentType=MonitorAgent,
buffer_size=100,
log_mode=False)
monitor_agent_2 = agentNetwork.add_agent(agentType=MonitorAgent,
buffer_size=300,
log_mode=False)
gen_agent_test1.init_agent_loop(loop_wait=0.01)
gen_agent_test2.init_parameters(scale_amplitude=0.3)
gen_agent_test2.init_agent_loop(loop_wait=0.01)
gen_agent_test3.init_parameters(scale_amplitude=0.6)
gen_agent_test3.init_agent_loop(loop_wait=0.01)
Trainer_Predictor_agent.init_parameters(
model_type="withLSTM"
) # define train_size and machine learning model types(
# withLSTM or withoutLSTM)
monitor_agent_1.init_parameters(
custom_plot_function=custom_create_monitor_graph_raw_data, )
monitor_agent_2.init_parameters(
custom_plot_function=custom_create_monitor_graph_calculation, )
# bind agents
agentNetwork.bind_agents(gen_agent_test1, aggregator_agent)
agentNetwork.bind_agents(gen_agent_test2, aggregator_agent)
agentNetwork.bind_agents(gen_agent_test3, aggregator_agent)
agentNetwork.bind_agents(aggregator_agent, disturbance_agent)
agentNetwork.bind_agents(disturbance_agent, Trainer_Predictor_agent)
agentNetwork.bind_agents(aggregator_agent, monitor_agent_1)
agentNetwork.bind_agents(Trainer_Predictor_agent, monitor_agent_2)
# set all agents states to "Running"
agentNetwork.set_running_state()
# allow for shutting down the network after execution
return agentNetwork
def test_zema_emc_lda_agents():
np.random.seed(100)
#start agent network server
agentNetwork = AgentNetwork(dashboard_modules=False)
#init agents by adding into the agent network
datastream_agent = agentNetwork.add_agent(agentType=DataStreamAgent)
train_test_split_agent = agentNetwork.add_agent(
agentType=TrainTestSplitAgent)
fft_bfc_agent = agentNetwork.add_agent(agentType=FFT_BFCAgent)
pearson_fs_agent = agentNetwork.add_agent(
agentType=Pearson_FeatureSelectionAgent)
lda_agent = agentNetwork.add_agent(agentType=LDA_Agent)
evaluator_agent = agentNetwork.add_agent(agentType=EvaluatorAgent)
monitor_agent = agentNetwork.add_agent(agentType=MonitorAgent)
#init parameters
datastream_agent.init_parameters(ZEMA_DataStream())
train_test_split_agent.init_parameters(train_ratio=0.8)
#bind agents
agentNetwork.bind_agents(datastream_agent, train_test_split_agent)
agentNetwork.bind_agents(train_test_split_agent, fft_bfc_agent)
agentNetwork.bind_agents(fft_bfc_agent, pearson_fs_agent)
agentNetwork.bind_agents(pearson_fs_agent, lda_agent)
agentNetwork.bind_agents(lda_agent, evaluator_agent)
#bind to monitor agents
agentNetwork.bind_agents(fft_bfc_agent, monitor_agent)
agentNetwork.bind_agents(pearson_fs_agent, monitor_agent)
agentNetwork.bind_agents(lda_agent, monitor_agent)
agentNetwork.bind_agents(evaluator_agent, monitor_agent)
#trigger datastream to send all at once
datastream_agent.send_all_sample()
time.sleep(timeout_wait)
assert lda_agent.get_attr('lda_test_score') == 0.8204924543288324
agentNetwork.shutdown()
