Hi ptrblck,
Yeap, please find my code snippet below:

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import syft as sy 
from torch.utils.data import Dataset
from torchvision import datasets, transforms
from resizeimage import resizeimage

class Arguments():
    def __init__(self):
        self.batch_size = 64
        self.test_batch_size = 1000
        self.epochs = 10
        self.lr = 0.01
        self.momentum = 0.5
        self.no_cuda = False
        self.seed = 1
        self.log_interval = 10
        self.save_model = False

args = Arguments()

use_cuda = not args.no_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 {}


hook = sy.TorchHook(torch)  # <-- NEW: hook PyTorch ie add extra functionalities to support Federated Learning
bob = sy.VirtualWorker(hook, id="bob")  # <-- NEW: define remote worker bob
alice = sy.VirtualWorker(hook, id="alice")  # <-- NEW: and alice

from scipy.io import loadmat
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.pyplot import imshow
import pandas as pd
from PIL import Image
from sklearn.model_selection import train_test_split

get_ipython().run_line_magic('matplotlib', 'inline')

frame = pd.read_csv('advanced/filename.csv')

ID_GENDER_MAP = {0: 'male', 1: 'female'}
GENDER_ID_MAP = dict((g, i) for i, g in ID_GENDER_MAP.items())
ID_RACE_MAP = {0: 'white', 1: 'black', 2: 'asian', 3: 'indian', 4: 'others'}
RACE_ID_MAP = dict((r, i) for i, r in ID_RACE_MAP.items())

frame['gender'] = frame['gender'].map(lambda gender: GENDER_ID_MAP[gender])
frame['race'] = frame['race'].map(lambda race: RACE_ID_MAP[race])
#print(frame)
count_row = frame.shape[0]

train, test = train_test_split(frame, test_size=0.2) 

train_data = list(map(lambda x: np.asarray(Image.open(x), dtype = 'float32'), train['file']))
train_labels = train.as_matrix(columns=train.columns[1:2])

test_data = list(map(lambda x: np.asarray(Image.open(x), dtype = 'float32'), test['file']))
test_labels = test.as_matrix(columns=test.columns[1:2])


train_data = np.asarray(train_data)
test_data = np.asarray(test_data)

# shape of data check
train_data.shape
test_data.shape


train_labels = np.asarray(train_labels, dtype = 'float32')
train_labels

test_labels = np.asarray(test_labels, dtype = 'float32')
test_labels

train_labels_after = train_labels[:,0]


np.array_equal(test_data, test_labels)


# Transpose the image arrays
train_data= train_data.transpose((0,3,1,2))
train_data.shape


base=sy.BaseDataset(torch.from_numpy(train_data),
                    torch.from_numpy(train_labels_after))
base_federated=base.federate((bob, alice))
federated_train_loader = sy.FederatedDataLoader( # <-- this is now a FederatedDataLoader 
                         base_federated,batch_size=args.batch_size)


def train(args, model, device, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(federated_train_loader): # <-- now it is a distributed dataset
        model.send(data.location) # <-- NEW: send the model to the right location
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        model.get() # <-- NEW: get the model back
        if batch_idx % args.log_interval == 0:
            loss = loss.get() # <-- NEW: get the loss back
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * args.batch_size, len(train_loader) * args.batch_size, #batch_idx * len(data), len(train_loader.dataset),
                100. * batch_idx / len(train_loader), loss.item()))



import torchvision
model = torchvision.models.vgg11(pretrained=False)
#model = torchvision.models.resnet101(pretrained=False)


model = model.to(device)
optimizer = optim.SGD(model.parameters(), lr=args.lr) # TODO momentum is not supported at the moment

print(model)
print(optimizer)


for epoch in range(1, args.epochs + 1):
    train(args, model, device, federated_train_loader, optimizer, epoch)