Telekinesis Inspired UX

[Nintorac]

This project looks very cool - https://www.telekinesis.cloud/

It's pretty early days for it and they don't seem to have any examples outside of notebook magic but I imagine you could use this concept to create a very simple UX for FL

My thinking goes like this,

• Replace their pod concept with an FLComponent
• For some nice syntactic sugar the FLCompent should implement a Context Manager

Here is a super simple example

# Get the client object, the client object exposes one or more FLComponents
client = nvflare.Client("client_identifier")

# mock some dummy data
x = torch.randn(100, 10)
y = torch.rand(100, 1).round()

# entering the client context
# all functions within this context block are executed remotely on the client
# the class on the client is initialized on entering the context and destroyed on exiting
with client.model as model:
    
    # x and y are implicitly turned into a DXO when referenced within the client context
    x, y = model.preprocess(x, y):
        
    for epoch in range(n_epochs):
        # somehow a message is sent to the client to run the forward function
        # the forward function will use the DXO of x and run it through their local model
        # y_hat will then be a new DXO (remote this time)
        y_hat = model.forward(x)

        loss = model.loss(y, y_hat)
        loss.backward()
    weights = model.named_parameters()

# outside of the context the weights is just a promise/future/whatever and needs to be awaited
await weights

For broadcast type requirements you could have a slightly different client object that matches on clients that can perform the task
something like

# Abstraction of client that matches all possible clients
client = nvflare.ClientMatch(study="sepsis", cohort="age<20")

# random data
x = torch.randn(100, 10)
y = torch.rand(100, 1).round()

with client.model(min_clients=2, max_clients=20, timeout=200) as model:
    z = x + y

# z is a list of results from all matching clients
await z

For the above I'm passing the data in, it would also be trivial for the client to access private data simply by loading it from the source in the init (i.e when calling with client.model) or any other way that is required

Perhaps the client doesn't actually have the data yet and only another client that is private to them can access the data directly. In this case you could have some interesting nested contexts.

client = nvflare.Client("client_id")


with client.model() as model:

    data_client = model.data_client()
    with data_client as data:
        # this is a nested context

        # The user cannot route the inner client directly
        # the inner client only allows certain  outputs from
        # certain to leave the context
        x_pii = data.x_pii
        y_pii = data.y_pii

        x = data.deid(x_pii)
        y = data.deid(y_pii)

    z_pii = x_pii + y_pii
    z = x + y

# succeeds
await z

# raises a permission denied exception
await z_pii

[chesterxgchen]

Allow us to digest your request first, and we might ask you more questions and elaborate idea a bit more.

[Nintorac]

Sounds good, looking forward to it!

I have implemented a proof of concept of the idea using some low level NVFlare components. Perhaps we could arrange a meeting to discuss if you would like?

[chesterxgchen]

Sorry to take me so long to get back to you. We were busy to get the new release out of door. I think now its good time. I am not sure you still have time or interests on this or not. you can reach to me directly [email protected]