def run(
self, epochs=1, self_learning_epochs=5, review_epochs=1, review_intervals={0: 100},
weights_computation_interval=100, test_interval=1000, batch_size=10, gamma_weight=100,
verbose=False):
self.accuracies = []
# self learning
self.self_learning(epochs=self_learning_epochs)
self.eval_accuracy()
self.change_weights(gamma_weight=100)
review_changes = np.asarray(list(review_intervals.keys()))[::-1]
Xs_len = len(self.X_shared)
total_iters = epochs*Xs_len
for ep in range(epochs):
# collective learning
for k in range(Xs_len//batch_size):
if verbose:
if self.agent.id == 0:
print("Remaining {}".format(total_iters-(ep*Xs_len+k*batch_size)), end="\r")
# produce collective proxy label
samples = self.X_shared[k*batch_size:(k+1)*batch_size]
proxy_labels = self.collective_prediction(samples, batch_size)
# train on proxy data
loss_value, grads = self.grad(tf.reshape(samples, (batch_size, 28, 28, 1)), proxy_labels)
self.optimizer.apply_gradients(zip(grads, self.model.trainable_variables), self.stepsize)
current_interval = review_changes[np.argmax(review_changes <= k*batch_size)]
if (k*batch_size) % review_intervals[current_interval] == 0:
self.self_learning(epochs=review_epochs)
if (k*batch_size) % 100 == 0:
# Generate a common graph (everyone use the same seed)
Adj = binomial_random_graph(self.agent.communicator.size, p=0.5, seed=(k*batch_size))
W = metropolis_hastings(Adj)
# create local agent
self.agent.set_neighbors(
in_neighbors=np.nonzero(Adj[self.agent.id, :])[0].tolist(),
out_neighbors=np.nonzero(Adj[:, self.agent.id])[0].tolist())
self.agent.set_weights(in_weights=W[self.agent.id, :].tolist())
if (k*batch_size) % weights_computation_interval == 0:
self.eval_accuracy()
self.change_weights(gamma_weight = gamma_weight)
if (k*batch_size) % test_interval == 0:
self.test()
self.accuracies.append(float(self.test_accuracy.numpy()))
if self.enable_log:
return self.accuracies
def generate_launch_description():
ap = argparse.ArgumentParser(prog='ros2 launch choirbot_examples containment.launch.py')
ap.add_argument("-n", "--number", help="number of robots", default=6, type=int)
ap.add_argument("-s", "--seed", help="seed for initial positions", default=3, type=int)
# parse arguments (exception thrown on error)
args, _ = ap.parse_known_args(sys.argv)
N = args.number # shorthand
# generate communication graph (this function also sets the seed)
Adj = binomial_random_graph(N, p=0.2, seed=args.seed)
# generate initial positions in [-3, 3] with z = 0
P = np.zeros((N, 3))
P[:, 0:2] = np.random.randint(-3, 3, (N, 2))
# initialize launch description with rviz executable
rviz_config_dir = get_package_share_directory('choirbot_examples')
rviz_config_file = os.path.join(rviz_config_dir, 'rvizconf.rviz')
launch_description = [Node(package='rviz2', node_executable='rviz2', output='screen',
arguments=['-d', rviz_config_file])]
# add executables for each robot
for i in range(N):
in_neighbors = np.nonzero(Adj[:, i])[0].tolist()
out_neighbors = np.nonzero(Adj[i, :])[0].tolist()
is_leader = True if i < N/2 else False
initial_pos = P[i, :].tolist()
# guidance
launch_description.append(Node(
package='choirbot_examples', node_executable='choirbot_containment_guidance', output='screen',
node_namespace='agent_{}'.format(i),
parameters=[{'agent_id': i, 'N': N, 'in_neigh': in_neighbors, 'out_neigh': out_neighbors, 'is_leader': is_leader}]))
# integrator
launch_description.append(Node(
package='choirbot_examples', node_executable='choirbot_containment_integrator', output='screen',
node_namespace='agent_{}'.format(i),
parameters=[{'agent_id': i, 'init_pos': initial_pos}]))
# rviz
launch_description.append(Node(
package='choirbot_examples', node_executable='choirbot_containment_rviz', output='screen',
node_namespace='agent_{}'.format(i),
parameters=[{'agent_id': i}]))
return LaunchDescription(launch_description)
import dill as pickle import numpy as np from mpi4py import MPI from disropt.agents import Agent from disropt.algorithms import ConstraintsConsensus from disropt.functions import Variable, SquaredNorm from disropt.utils.graph_constructor import binomial_random_graph from disropt.problems import Problem # get MPI info NN = MPI.COMM_WORLD.Get_size() agent_id = MPI.COMM_WORLD.Get_rank() # Generate a common graph (everyone uses the same seed) Adj = binomial_random_graph(NN, p=0.03, seed=1) np.random.seed(10 * agent_id) ##################### # Problem parameters ##################### # parameters of gaussians mu = (np.array([0, 0]).transpose(), np.array([3, 2]).transpose()) sigma = (np.eye(2), np.eye(2)) dim = mu[0].shape[0] # dimension of sample space # number of samples (min 2 max 5 for each label) nsamp = (np.random.randint(2, 6), np.random.randint(2, 6))
from mpi4py import MPI
from disropt.agents import Agent
from disropt.algorithms.subgradient import BlockSubgradientMethod
from disropt.functions import QuadraticForm, Variable, SquaredNorm
from disropt.utils.utilities import is_pos_def
from disropt.constraints.projection_sets import Box
from disropt.utils.graph_constructor import binomial_random_graph, metropolis_hastings
from disropt.problems import Problem
# get MPI info
comm = MPI.COMM_WORLD
nproc = comm.Get_size()
local_rank = comm.Get_rank()
# Generate a common graph (everyone use the same seed)
Adj = binomial_random_graph(nproc, p=0.3, seed=1)
W = metropolis_hastings(Adj)
# reset local seed
np.random.seed(local_rank)
agent = Agent(in_neighbors=np.nonzero(Adj[local_rank, :])[0].tolist(),
out_neighbors=np.nonzero(Adj[:, local_rank])[0].tolist(),
in_weights=W[local_rank, :].tolist())
# variable dimension
n = 6
# generate a positive definite matrix
P = np.random.randn(n, n)
P = P.transpose() @ P
def generate_launch_description():
ap = argparse.ArgumentParser(
prog='ros2 launch choirbot_examples taskassignment.launch.py')
ap.add_argument("-n",
"--number",
help="number of robots",
default=4,
type=int)
ap.add_argument("-s",
"--seed",
help="seed for initial positions",
default=3,
type=int)
# parse arguments (exception thrown on error)
args, _ = ap.parse_known_args(sys.argv)
N = args.number
# generate communication graph (this function also sets the seed)
Adj = binomial_random_graph(N, 0.2, seed=args.seed)
# generate initial positions in [-3, 3] with z = 0
P = np.zeros((N, 3))
P[:, 0:2] = np.random.randint(-3, 3, (N, 2))
# initialize launch description
robot_launch = [] # launched after 10 sec (to let Gazebo open)
launch_description = [] # launched immediately (will contain robot_launch)
# add task table executable
robot_launch.append(
Node(package='choirbot_examples',
node_executable='choirbot_taskassignment_table',
output='screen',
prefix=['xterm -hold -e'],
parameters=[{
'N': N
}]))
# add executables for each robot
for i in range(N):
in_neighbors = np.nonzero(Adj[:, i])[0].tolist()
out_neighbors = np.nonzero(Adj[i, :])[0].tolist()
position = P[i, :].tolist()
# guidance
robot_launch.append(
Node(package='choirbot_examples',
node_executable='choirbot_taskassignment_guidance',
output='screen',
prefix=['xterm -hold -e'],
node_namespace='agent_{}'.format(i),
parameters=[{
'agent_id': i,
'N': N,
'in_neigh': in_neighbors,
'out_neigh': out_neighbors
}]))
# planner
robot_launch.append(
Node(package='choirbot_examples',
node_executable='choirbot_taskassignment_planner',
output='screen',
node_namespace='agent_{}'.format(i),
parameters=[{
'agent_id': i
}]))
# controller
robot_launch.append(
Node(package='choirbot_examples',
node_executable='choirbot_taskassignment_controller',
output='screen',
node_namespace='agent_{}'.format(i),
parameters=[{
'agent_id': i
}]))
# turtlebot spawner
launch_description.append(
Node(package='choirbot_examples',
node_executable='choirbot_turtlebot_spawner',
output='screen',
parameters=[{
'namespace': 'agent_{}'.format(i),
'position': position
}]))
# include launcher for gazebo
gazebo_launcher = os.path.join(
get_package_share_directory('choirbot_examples'), 'gazebo.launch.py')
launch_description.append(
IncludeLaunchDescription(
PythonLaunchDescriptionSource(gazebo_launcher)))
# include delayed robot executables
timer_action = TimerAction(period=10.0,
actions=[LaunchDescription(robot_launch)])
launch_description.append(timer_action)
return LaunchDescription(launch_description)
