def wroker_config(args):
hook = sy.TorchHook(torch)
logger.info("Worker setup.\n")
if args.use_virtual:
alice = VirtualWorker(id="alice", hook=hook, verbose=args.verbose)
bob = VirtualWorker(id="bob", hook=hook, verbose=args.verbose)
charlie = VirtualWorker(id="charlie", hook=hook, verbose=args.verbose)
workers = [alice, bob, charlie]
else:
if args.localworkers:
kwargs_websocket = {
"host": "localhost",
"hook": hook,
"verbose": args.verbose
}
alice = WebsocketClientWorker(id="alice",
port=8777,
**kwargs_websocket)
bob = WebsocketClientWorker(id="bob",
port=8778,
**kwargs_websocket)
charlie = WebsocketClientWorker(id="charlie",
port=8779,
**kwargs_websocket)
workers = [alice, bob, charlie]
else:
kwargs_websocket_Pi4_R1_1 = {
"host": "128.226.77.157",
"hook": hook
}
Pi4_R1_1 = WebsocketClientWorker(id="Pi4_R1_1",
port=8777,
**kwargs_websocket_Pi4_R1_1)
kwargs_websocket_Pi4_R1_2 = {
"host": "128.226.78.128",
"hook": hook
}
Pi4_R1_2 = WebsocketClientWorker(id="Pi4_R1_2",
port=8777,
**kwargs_websocket_Pi4_R1_2)
kwargs_websocket_Pi4_R1_3 = {
"host": "128.226.88.155",
"hook": hook
}
Pi4_R1_3 = WebsocketClientWorker(id="Pi4_R1_3",
port=8777,
**kwargs_websocket_Pi4_R1_3)
kwargs_websocket_Pi4_R1_4 = {"host": "128.226.79.31", "hook": hook}
Pi4_R1_4 = WebsocketClientWorker(id="Pi4_R1_4",
port=8777,
**kwargs_websocket_Pi4_R1_4)
workers = [Pi4_R1_1, Pi4_R1_2, Pi4_R1_3, Pi4_R1_4]
return workers
async def handle_worker(websocket,
path,
hook,
workers,
update_queue,
results_box,
model,
optimizer,
learning_rate,
verbose=False):
global syft_port_next
message = json.loads(await websocket.recv())
action = message['action']
if action == 'get_available_port':
log('Sending current available syft port %d' % syft_port_next, verbose)
message = json.dumps({'success': True, 'syft_port': syft_port_next})
await websocket.send(message)
syft_port_next += 1
if action == 'register':
name, host, syft_port = message['name'], message['host'], message[
'syft_port']
new_worker = WebsocketClientWorker(host=host,
hook=hook,
id=name,
port=syft_port,
log_msgs=True,
verbose=verbose,
is_client_worker=False)
workers[name] = new_worker
optimizer[workers[name]] = torch.optim.Adam(model.parameters(),
lr=learning_rate)
message = json.dumps({'success': True, 'num_peers': len(workers)})
log('Worker %s (%s) registered, port %d' % (name, host, syft_port),
verbose)
await websocket.send(message)
elif action == 'request_model':
name = message['name']
log('Put %s into update queue' % name, verbose)
update_queue.put(name)
message = json.dumps({'success': True})
await websocket.send(message)
elif action == 'ping_conductor':
name = message['name']
result = {'in_queue': name in update_queue, 'num_peers': len(workers)}
#log('conductor pinged: send back %s %s' % (name, 'True' if result['in_queue'] else 'False'), verbose)
if not result['in_queue'] and name in results_box:
result['user'] = results_box[name]
message = json.dumps(result, cls=NumpyArrayEncoder)
await websocket.send(message)
def connect_to_nodes(nodes):
hook = syft.TorchHook(torch)
workers = []
for i in range(2, int(nodes) + 1):
ip = '10.0.0.{}'.format(str(i))
socket = {"host": ip, "hook": hook, "verbose": True}
worker_name = 'h{}'.format(str(i))
clientworker = WebsocketClientWorker(id=worker_name,
port=8778,
**socket)
workers.append(clientworker)
return workers
async def fit_model_on_worker(worker: WebsocketClientWorker,
traced_model: torch.jit.ScriptModule,
batch_size: int, curr_round: int, lr: float,
no_federated_epochs: int):
train_config = syft.TrainConfig(
model=traced_model,
loss_fn=loss_fn,
batch_size=batch_size,
shuffle=True,
epochs=no_federated_epochs,
optimizer="SGD",
optimizer_args={"lr": lr},
)
#send monitoring command
message = worker.create_message_execute_command(
command_name="start_monitoring", command_owner="self")
serialized_message = syft.serde.serialize(message)
worker._recv_msg(serialized_message)
#send the training config
train_config.send(worker)
#Call async fit on worker - async fit calls the method calls self fit method
print("Training round {}, calling fit on worker: {}".format(
curr_round, worker.id))
loss = await worker.async_fit(dataset_key="targeted", return_ids=[0])
print("Training round: {}, worker: {}, avg_loss: {}".format(
curr_round, worker.id, loss.item()))
#Call back to the model
model = train_config.get_model().obj
#Stop monitoring command
message = worker.create_message_execute_command(
command_name="stop_monitoring", command_owner="self")
serialized_message = syft.serde.serialize(message)
network_info = worker._recv_msg(serialized_message)
#Deserialize the response recieved
network_info = syft.serde.deserialize(network_info)
return worker.id, model, loss, network_info
def instance(args,kwargs_websocket):
""" instance the workers
args:
args: the arguments
kwargs_websocket: the dict of host and hook
Return:
worker_instances: the list of the workers instances
"""
clients = []
for i in range(args.clients):
clients.append(WebsocketClientWorker(id=str(i), port=args.client_port+i, **kwargs_websocket))
worker_instances = [client for client in clients]
for worker in worker_instances:
print("Client: " ,worker)
return worker_instances
def test_create_already_existing_worker_with_different_type(hook, start_proc):
# Shares tensor with bob
bob = sy.VirtualWorker(hook, "bob")
_ = th.tensor([1, 2, 3]).send(bob)
kwargs = {"id": "fed1", "host": "localhost", "port": 8765, "hook": hook}
server = start_proc(WebsocketServerWorker, **kwargs)
time.sleep(0.1)
# Recreates bob as a different type of worker
kwargs = {"id": "bob", "host": "localhost", "port": 8765, "hook": hook}
with pytest.raises(RuntimeError):
bob = WebsocketClientWorker(**kwargs)
server.terminate()
def main():
hook = sy.TorchHook(torch)
squad = WebsocketClientWorker(id=1,
host='localhost',
port=7171,
hook=hook,
verbose=True)
message = data
message_ptr = message.send(squad)
print(message_ptr)
print('sent model data. now squad has %d objects' %
(message_ptr.location.objects_count_remote()))
# get squad updated model
model = nn.Linear(1, 1)
train(model)
def instantiate_websocket_client_worker(max_tries=5, sleep_time=0.1, **kwargs): # pragma: no cover
"""Helper function to instantiate the websocket client.
If a connection is refused, we wait a bit (`sleep_time` seconds) and try again.
After `max_tries` failed tries, a ConnectionRefusedError is raised.
"""
retry_counter = 0
connection_open = False
while not connection_open:
try:
remote_proxy = WebsocketClientWorker(**kwargs)
connection_open = True
except ConnectionRefusedError as e:
if retry_counter < max_tries:
retry_counter += 1
time.sleep(sleep_time)
else:
raise e
return remote_proxy
import torch
import syft
from syft.workers.websocket_server import WebsocketServerWorker
from syft.workers.websocket_client import WebsocketClientWorker
hook = syft.TorchHook(torch)
#local_worker = WebsocketServerWorker(host='localhost', hook=hook, id=0, port=8182, log_msgs=True, verbose=True)
#hook = syft.TorchHook(torch, local_worker=local_worker)
remote_client = WebsocketClientWorker(host='localhost',
hook=hook,
id=2,
port=8182,
log_msgs=True,
verbose=True)
hook.local_worker.add_worker(remote_client)
y = torch.tensor([1, 2, 3, 2, 4])
y.send(remote_client)
x = torch.tensor([3, 1, 5, -1, 0, 44])
x.send(remote_client)
# 7) change those weights
opt.step()
# 8) get model (with gradients)
model_c = model_c.get()
# 9) print our progress
print(data.location.id, loss.get())
return model_c
if __name__ == '__main__':
# create a client workers mapping to the server workers in remote machines
# remote_client_1 = PublicGridNetwork(hook=hook, gateway_url='http://localhost:8182')
# remote_client_2 = PublicGridNetwork(hook=hook, gateway_url='http://localhost:8183')
remote_client_1 = WebsocketClientWorker(
host='localhost',
# host = '192.168.0.102', # the host of remote machine, the same as the Server host
hook=hook,
id='server1',
port=8182)
remote_client_2 = WebsocketClientWorker(
host='localhost',
# host = '192.168.0.102', # the host of remote machine, the same as the Server host
hook=hook,
id='server2',
port=8183)
remote_clients_list = [remote_client_1, remote_client_2]
print('>>> remote_client_1', remote_client_1)
print('>>> remote_client_2', remote_client_2)
# get the data pointers which point to the real data in remote machines for training model
datasets = []
for remote_client in remote_clients_list:
def make_remote_client(host, hook, id, port):
from syft.workers.websocket_client import WebsocketClientWorker
return WebsocketClientWorker(host=host, hook=hook, id=id, port=port)
dim=1,
keepdim=True) # get the index of the max log-probability
correct += pred.eq(target.view_as(pred)).sum().item()
test_loss /= len(test_loader.dataset)
print(
'\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
test_loss, correct, len(test_loader.dataset),
100. * correct / len(test_loader.dataset)))
if __name__ == "__main__":
hook = sy.TorchHook(torch)
kwargs_websocket = {"host": "localhost", "hook": hook}
alice = WebsocketClientWorker(id="alice", port=8777, **kwargs_websocket)
device = torch.device("cuda" if use_cuda else "cpu")
# workers = [alice, bob, charlie]
workers = [alice]
grid = sy.PrivateGridNetwork(*workers)
data = grid.search("#mnist", "#data")
print(f"Search data: {len(data.keys())}")
target = grid.search("#mnist", "#target")
print(f"Search target: {len(target.keys())}")
datasets_my = []
for worker in data.keys():
dataset = sy.BaseDataset(data[worker][0], target[worker][0])
def main():
args = define_and_get_arguments()
hook = sy.TorchHook(torch)
if args.use_virtual:
alice = VirtualWorker(id="alice", hook=hook, verbose=args.verbose)
bob = VirtualWorker(id="bob", hook=hook, verbose=args.verbose)
charlie = VirtualWorker(id="charlie", hook=hook, verbose=args.verbose)
else:
kwargs_websocket = {
"host": "localhost",
"hook": hook,
"verbose": args.verbose
}
alice = WebsocketClientWorker(id="alice",
port=8777,
**kwargs_websocket)
bob = WebsocketClientWorker(id="bob", port=8778, **kwargs_websocket)
charlie = WebsocketClientWorker(id="charlie",
port=8779,
**kwargs_websocket)
workers = [alice, bob, charlie]
use_cuda = args.cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
device = torch.device("cuda" if use_cuda else "cpu")
kwargs = {"num_workers": 1, "pin_memory": True} if use_cuda else {}
federated_train_loader = sy.FederatedDataLoader(
datasets.MNIST(
"../data",
train=True,
download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
]),
).federate(tuple(workers)),
batch_size=args.batch_size,
shuffle=True,
iter_per_worker=True,
**kwargs,
)
test_loader = torch.utils.data.DataLoader(
datasets.MNIST(
"../data",
train=False,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
]),
),
batch_size=args.test_batch_size,
shuffle=True,
**kwargs,
)
model = Net().to(device)
for epoch in range(1, args.epochs + 1):
logger.info("Starting epoch %s/%s", epoch, args.epochs)
model = train(model, device, federated_train_loader, args.lr,
args.federate_after_n_batches)
test(model, device, test_loader)
if args.save_model:
torch.save(model.state_dict(), "mnist_cnn.pt")
def run_train_test(workers, ports, ids, X_train, X_test, y_train, y_test,
encoder):
# Hook PyTorch ie add extra functionalities to support Federated Learning
hook = sy.TorchHook(torch)
# Sets the seed for generating random numbers.
torch.manual_seed(1)
# Select CPU computation, in case you want GPU use "cuda" instead
device = torch.device("cpu")
# Data will be distributed among these VirtualWorkers.
# Remote training of the model will happen here.
kwargs_websocket_bob = {"host": workers[1], "hook": hook}
#gatway2 = sy.VirtualWorker(hook, id="gatway2")
gatway2 = WebsocketClientWorker(id=ids[1],
port=ports[1],
**kwargs_websocket_bob)
kwargs_websocket_alice = {"host": workers[0], "hook": hook}
#gatway1 = sy.VirtualWorker(hook, id="gatway1")
gatway1 = WebsocketClientWorker(id=ids[0],
port=ports[0],
**kwargs_websocket_alice)
#kwargs_websocket_bob2 = {"host": workers[2], "hook": hook}
#gatway2 = sy.VirtualWorker(hook, id="gatway2")
#gatway3 = WebsocketClientWorker(id=ids[2], port=ports[2], **kwargs_websocket_bob2)
#kwargs_websocket_alice2 = {"host": workers[3], "hook": hook}
#gatway1 = sy.VirtualWorker(hook, id="gatway1")
#gatway4= WebsocketClientWorker(id=ids[3], port=ports[3], **kwargs_websocket_alice2)
# Number of times we want to iterate over whole training data
#gatway3=sy.VirtualWorker(hook, id="gatway3")
#gatway4=sy.VirtualWorker(hook, id="gatway4")
BATCH_SIZE = 1000
EPOCHS = 5
LOG_INTERVAL = 5
lr = 0.01
n_feature = X_train.shape[1]
n_class = np.unique(y_train).shape[0]
print("Number of training features : ", n_feature)
print("Number of training classes : ", n_class)
# Create pytorch tensor from X_train,y_train,X_test,y_test
train_inputs = torch.tensor(X_train,
dtype=torch.float).tag("#iot", "#network",
"#data", "#train")
train_labels = torch.tensor(y_train).tag("#iot", "#network", "#target",
"#train")
test_inputs = torch.tensor(X_test,
dtype=torch.float).tag("#iot", "#network",
"#data", "#test")
test_labels = torch.tensor(y_test).tag("#iot", "#network", "#target",
"#test")
# Send the training and test data to the gatways in equal proportion.
train_idx = int(len(train_labels) / 2)
test_idx = int(len(test_labels) / 2)
gatway1_train_dataset = sy.BaseDataset(
train_inputs[:train_idx], train_labels[:train_idx]).send(gatway1)
gatway2_train_dataset = sy.BaseDataset(
train_inputs[train_idx:2 * train_idx],
train_labels[train_idx:2 * train_idx]).send(gatway2)
#gatway3_train_dataset = sy.BaseDataset(train_inputs[2*train_idx:3*train_idx], train_labels[2*train_idx:3*train_idx]).send(gatway3)
#gatway4_train_dataset = sy.BaseDataset(train_inputs[3*train_idx:], train_labels[3*train_idx:]).send(gatway4)
gatway1_test_dataset = sy.BaseDataset(test_inputs[:test_idx],
test_labels[:test_idx]).send(gatway1)
gatway2_test_dataset = sy.BaseDataset(test_inputs[test_idx:2 * test_idx],
test_labels[test_idx:2 *
test_idx]).send(gatway2)
#gatway3_test_dataset = sy.BaseDataset(test_inputs[2*test_idx:2*test_idx], test_labels[2*test_idx:3*test_idx]).send(gatway3)
#gatway4_test_dataset = sy.BaseDataset(test_inputs[3*test_idx:], test_labels[3*test_idx:]).send(gatway3)
# Create federated datasets, an extension of Pytorch TensorDataset class
federated_train_dataset = sy.FederatedDataset([
gatway1_train_dataset, gatway2_train_dataset
]) #,gatway3_train_dataset,gatway4_train_dataset])
federated_test_dataset = sy.FederatedDataset(
[gatway1_test_dataset,
gatway2_test_dataset]) #,gatway3_test_dataset,gatway4_test_dataset])
# Create federated dataloaders, an extension of Pytorch DataLoader class
federated_train_loader = sy.FederatedDataLoader(federated_train_dataset,
shuffle=True,
batch_size=BATCH_SIZE)
federated_test_loader = sy.FederatedDataLoader(federated_test_dataset,
shuffle=False,
batch_size=BATCH_SIZE)
# Initialize the model
model = Net(n_feature, n_class)
#Initialize the SGD optimizer
optimizer = optim.SGD(model.parameters(), lr=lr)
for epoch in range(1, EPOCHS + 1):
# Train on the training data in a federated way
start1 = datetime.datetime.now()
model = train(model, device, federated_train_loader, optimizer, epoch,
BATCH_SIZE, LOG_INTERVAL)
end1 = datetime.datetime.now()
print("Time Taken to train epoch %d is ", end1 - start1)
if epoch == 1:
total = end1 - start1
else:
total += end1 - start1
# Check the test accuracy on unseen test data in a federated way
start2 = datetime.datetime.now()
test(model, device, federated_test_loader)
end2 = datetime.datetime.now()
print("Time Taken to test epoch %d is ", end2 - start2)
print("Total training time = ", total)
# Save the model
torch.save(model.state_dict(), "binaize-threat-model_10.pt")
# Reload the model in a new model object
model_new = Net(n_feature, n_class)
model_new.load_state_dict(torch.load("binaize-threat-model_10.pt"))
model_new.eval()
process = os.popen(
"sudo scp -i /root/.ssh/id_rsa -o stricthostkeychecking=no binaize-threat-model_fully_trained.pt root@%s:/home/ayush/ADS/predict_workers"
% (workers[0]))
output = process.read()
process = os.popen(
"sudo scp -i /root/.ssh/id_rsa -o stricthostkeychecking=no binaize-threat-model_fully_trained.pt root@%s:/home/ayush/ADS/predict_workers"
% (workers[1]))
output = process.read()
# Take the 122th record from the test data
idx = 122
data = test_inputs[idx]
pred = model_new(data)
pred_label = int(pred.argmax().data.cpu().numpy())
pred_threat = encoder.inverse_transform([pred_label])[0]
print("Predicted threat type : ", pred_threat)
actual_label = int(test_labels[idx].data.cpu().numpy())
actual_threat = encoder.inverse_transform([actual_label])[0]
print("Actual threat type : ", actual_threat)
# Take the 159th record from the test data
idx = 159
data = test_inputs[idx]
pred = model_new(data)
pred_label = int(pred.argmax().data.cpu().numpy())
pred_threat = encoder.inverse_transform([pred_label])[0]
print("Predicted threat type : ", pred_threat)
actual_label = int(test_labels[idx].data.cpu().numpy())
actual_threat = encoder.inverse_transform([actual_label])[0]
print("Actual threat type : ", actual_threat)
def main():
args = define_and_get_arguments()
hook = sy.TorchHook(torch)
# 가상작업자(시뮬레이션) 사용시 이곳으로 분기
if args.use_virtual:
alice = VirtualWorker(id="alice", hook=hook, verbose=args.verbose)
bob = VirtualWorker(id="bob", hook=hook, verbose=args.verbose)
charlie = VirtualWorker(id="charlie", hook=hook, verbose=args.verbose)
list_of_object = [alice, bob, charlie]
# 웹소켓작업자 사용시 이곳으로 분기
else:
base_port = 10002
list_of_id = ["alice", "bob", "charlie"]
list_of_ip = ["192.168.0.52", "192.168.0.53", "192.168.0.54"]
list_of_object = []
for index in range(len(list_of_id)):
kwargs_websockest = {"id": list_of_id[index], "hook": hook}
list_of_object.append(
WebsocketClientWorker(host=list_of_ip[index],
port=base_port,
**kwargs_websockest))
workers = list_of_object
use_cuda = args.cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
device = torch.device("cuda" if use_cuda else "cpu")
kwargs = {"num_workers": 1, "pin_memory": True} if use_cuda else {}
federated_train_loader = sy.FederatedDataLoader(
datasets.MNIST(
"../data",
train=True,
download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
]),
).federate(tuple(workers)),
batch_size=args.batch_size,
shuffle=True,
iter_per_worker=True,
**kwargs,
)
test_loader = torch.utils.data.DataLoader(
datasets.MNIST(
"../data",
train=False,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
]),
),
batch_size=args.test_batch_size,
shuffle=True,
**kwargs,
)
model = Net().to(device)
for epoch in range(1, args.epochs + 1):
logger.info("Starting epoch %s/%s", epoch, args.epochs)
model = train(model, device, federated_train_loader, args.lr,
args.federate_after_n_batches)
test(model, device, test_loader)
if args.save_model:
torch.save(model.state_dict(), "mnist_cnn.pt")
def main():
args = define_and_get_arguments()
hook = sy.TorchHook(torch)
# 가상작업자(시뮬레이션) 사용시 이곳으로 분기
if args.use_virtual:
alice = VirtualWorker(id="alice", hook=hook, verbose=args.verbose)
bob = VirtualWorker(id="bob", hook=hook, verbose=args.verbose)
charlie = VirtualWorker(id="charlie", hook=hook, verbose=args.verbose)
# 웹소켓작업자 사용시 이곳으로 분기
else:
a_kwargs_websocket = {"host": "192.168.0.57", "hook": hook}
b_kwargs_websocket = {"host": "192.168.0.58", "hook": hook}
c_kwargs_websocket = {"host": "192.168.0.59", "hook": hook}
baseport = 10002
alice = WebsocketClientWorker(id="alice",
port=baseport,
**a_kwargs_websocket)
bob = WebsocketClientWorker(id="bob",
port=baseport,
**b_kwargs_websocket)
charlie = WebsocketClientWorker(id="charlie",
port=baseport,
**c_kwargs_websocket)
# 워커 객체를 리스트로 묶음
workers = [alice, bob, charlie]
# 쿠다 사용 여부
use_cuda = args.cuda and torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
kwargs = {"num_workers": 1, "pin_memory": True} if use_cuda else {}
# 랜덤 시드 설정
torch.manual_seed(args.seed)
labels_resampled_factorized, obs_resampled_with_noise_2 = process_data()
# percentage of test/valid set to use for testing and validation from the test_valid_idx (to be called test_size)
test_size = 0.1
# obtain training indices that will be used for validation
num_train = len(obs_resampled_with_noise_2)
indices = list(range(num_train))
np.random.shuffle(indices)
split = int(np.floor(test_size * num_train))
train_idx, test_idx = indices[split:], indices[:split]
federated_train_dataset = D.TensorDataset(
torch.tensor(obs_resampled_with_noise_2[train_idx]),
torch.tensor(labels_resampled_factorized[train_idx]))
federated_train_loader = sy.FederatedDataLoader(
federated_train_dataset.federate(tuple(workers)),
batch_size=args.batch_size,
shuffle=True,
iter_per_worker=True,
**kwargs,
)
test_dataset = D.TensorDataset(
torch.tensor(obs_resampled_with_noise_2[test_idx]),
torch.tensor(labels_resampled_factorized[test_idx]))
test_loader = D.DataLoader(test_dataset,
shuffle=True,
batch_size=args.batch_size,
num_workers=0,
drop_last=True)
model = Net(input_features=1, output_dim=5).to(device)
criterion = nn.NLLLoss()
for epoch in range(1, args.epochs + 1):
logger.info("Starting epoch %s/%s", epoch, args.epochs)
model = train(model,
device,
federated_train_loader,
args.lr,
args.federate_after_n_batches,
criterion=criterion)
test(model,
test_loader,
args.batch_size,
criterion=criterion,
train_on_gpu=use_cuda)
if args.save_model:
torch.save(model.state_dict(), "./Model/mnist_cnn.pt")
import torch
import syft as sy
from syft.workers.websocket_client import WebsocketClientWorker
from syft.exceptions import ObjectNotFoundError
if __name__ == "__main__":
hook = sy.TorchHook(torch)
bad = WebsocketClientWorker(id="bad",
port=8777,
host="localhost",
hook=hook)
good = WebsocketClientWorker(id="good",
port=8778,
host="localhost",
hook=hook)
# When staring server, we already register a tensor
# object with tab "test" in the server worker
try:
print("Search test with bad")
data_pt = bad.search("test")
except ObjectNotFoundError:
print("Error: test is not found with bad worker!!!")
print("Search test with good")
data_pt = good.search("test")
print("Test is found with good worker!!!")
print("Here is the test data")
# def inverse_transform(scalar, df, columns):
# for col in columns:
# df[col] = scaler.inverse_transform(df[col])
# return df
bob_cl = '7'
alice_cl = '0'
target_cl = '15'
cluster = bob_cl
hook = sy.TorchHook(torch)
# bob = sy.VirtualWorker(hook, id="bob")
# alice = sy.VirtualWorker(hook, id="alice")
kwargs_websocket = {"host": "localhost", "hook": hook}
alice = WebsocketClientWorker(id='alice', port=8779, **kwargs_websocket)
bob = WebsocketClientWorker(id='bob', port=8778, **kwargs_websocket)
compute_nodes = [bob, alice]
bob_train, bob_test, bob_val = load_data(bob_cl)
alice_train, alice_test, alice_val = load_data(alice_cl)
target_train, target_test, target_val = load_data(target_cl)
remote_dataset = (list(), list())
train_distributed_dataset = []
for batch_idx, (data, target) in enumerate(bob_train):
data = data.send(compute_nodes[0])
target = target.send(compute_nodes[0])
remote_dataset[0].append((data, target))
for batch_idx, (data, target) in enumerate(alice_train):
data = data.send(compute_nodes[1])
async def test_train_config_with_jit_trace_async(
hook, start_proc): # pragma: no cover
kwargs = {
"id": "async_fit",
"host": "localhost",
"port": 8777,
"hook": hook
}
# data = torch.tensor([[0.0, 1.0], [1.0, 0.0], [1.0, 1.0], [0.0, 0.0]], requires_grad=True)
# target = torch.tensor([[1.0], [1.0], [0.0], [0.0]], requires_grad=False)
# dataset_key = "xor"
data, target = utils.create_gaussian_mixture_toy_data(100)
dataset_key = "gaussian_mixture"
mock_data = torch.zeros(1, 2)
# TODO check reason for error (RuntimeError: This event loop is already running) when starting websocket server from pytest-asyncio environment
# dataset = sy.BaseDataset(data, target)
# server, remote_proxy = start_remote_worker(id="async_fit", port=8777, hook=hook, dataset=(dataset, dataset_key))
# time.sleep(0.1)
remote_proxy = WebsocketClientWorker(**kwargs)
@hook.torch.jit.script
def loss_fn(pred, target):
return ((target.view(pred.shape).float() - pred.float())**2).mean()
class Net(torch.nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(2, 3)
self.fc2 = nn.Linear(3, 2)
self.fc3 = nn.Linear(2, 1)
def forward(self, x):
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
model_untraced = Net()
model = torch.jit.trace(model_untraced, mock_data)
pred = model(data)
loss_before = loss_fn(target=target, pred=pred)
# Create and send train config
train_config = sy.TrainConfig(model=model,
loss_fn=loss_fn,
batch_size=2,
optimizer="SGD",
optimizer_args={"lr": 0.1})
train_config.send(remote_proxy)
for epoch in range(5):
loss = await remote_proxy.async_fit(dataset_key=dataset_key)
if PRINT_IN_UNITTESTS: # pragma: no cover
print("-" * 50)
print("Iteration %s: alice's loss: %s" % (epoch, loss))
new_model = train_config.model_ptr.get()
assert not (model.fc1._parameters["weight"]
== new_model.obj.fc1._parameters["weight"]).all()
assert not (model.fc2._parameters["weight"]
== new_model.obj.fc2._parameters["weight"]).all()
assert not (model.fc3._parameters["weight"]
== new_model.obj.fc3._parameters["weight"]).all()
assert not (model.fc1._parameters["bias"]
== new_model.obj.fc1._parameters["bias"]).all()
assert not (model.fc2._parameters["bias"]
== new_model.obj.fc2._parameters["bias"]).all()
assert not (model.fc3._parameters["bias"]
== new_model.obj.fc3._parameters["bias"]).all()
new_model.obj.eval()
pred = new_model.obj(data)
loss_after = loss_fn(target=target, pred=pred)
if PRINT_IN_UNITTESTS: # pragma: no cover
print("Loss before training: {}".format(loss_before))
print("Loss after training: {}".format(loss_after))
remote_proxy.close()
# server.terminate()
assert loss_after < loss_before
hook = sy.TorchHook(torch)
config = SearchConfig()
default_device = torch.device("cuda:0")
# tensorboard
writer = SummaryWriter(log_dir=os.path.join(config.path, "tb"))
writer.add_text('config', config.as_markdown(), 0)
logger = utils.get_logger(
os.path.join(config.path, "{}.log".format(config.name)))
config.print_params(logger.info)
kwargs_websocket = {"hook": hook, "host": "0.0.0.0"}
alice = WebsocketClientWorker(id="0", port=8777, **kwargs_websocket)
bob = WebsocketClientWorker(id="1", port=8778, **kwargs_websocket)
workers = [alice, bob]
for wcw in workers:
wcw.clear_objects_remote()
# hook.local_worker.add_worker(wcw)
remote_train_data = ([], [])
remote_valid_data = ([], [])
async def main():
logger.info("Logger is set - training start")
# set default gpu device id
from torchvision import transforms
from torchvision.utils import save_image
from torch.autograd import Variable
import syft as sy
from syft.workers.websocket_server import WebsocketServerWorker
from syft.workers.websocket_client import WebsocketClientWorker
# setup workers
hook = sy.TorchHook(torch)
#bob = sy.VirtualWorker(hook, id="bob")
#alice = sy.VirtualWorker(hook, id="alice")
rc1 = WebsocketClientWorker(host='localhost',
hook=hook,
id='0',
port=8182,
log_msgs=True,
verbose=True)
rc2 = WebsocketClientWorker(host='localhost',
hook=hook,
id='1',
port=8183,
log_msgs=True,
verbose=True)
rc3 = WebsocketClientWorker(host='localhost',
hook=hook,
id='2',
port=8184,
log_msgs=True,
verbose=True)
rc4 = WebsocketClientWorker(host='localhost',
import torch
from torch import optim
import syft
from syft.workers.websocket_client import WebsocketClientWorker
hook = syft.TorchHook(torch)
# create a client worker mapping to the server worker in remote machine
remote_client = WebsocketClientWorker(
host=
'192.168.0.102', # the host of remote machine, the same a the Server host
hook=hook,
id='liuwang',
port=8182)
print('>>> remote_client', remote_client)
# get the data pointers which point to the real data in remote machine for training model locally
features = remote_client.search(["toy", "features"])
labels = remote_client.search(["toy", "labels"])
print('>>> x:', features)
print('>>> y:', labels)
# a toy model
model = torch.nn.Linear(2, 1)
remote_model = model.copy().send(remote_client)
def train(x, y, N) -> torch.nn.Module:
# Training Logic
opt = optim.SGD(params=remote_model.parameters(), lr=0.1)
for iter in range(N):
# 1) erase previous gradients (if they exist)
opt.zero_grad()
