Additional details for Federated Learning implementation

train_gen = ImageDataGenerator(rotation_range=8,
                                width_sht_range=0.08,
                                shear_range=0.3,
                                height_shift_range=0.08,
                                zoom_range=0.08)

    train_datagenerator = train_gen.flow(
        x_train, y_train, batch_size=64)

    return train_datagenerator

import numpy as np

# imports from ibmfl
from ibmfl.data.data_handler import DataHandler
from ibmfl.exceptions import FLException



class MnistKerasDataHandler(DataHandler):
    """
    Data handler for MNIST dataset.
    """

    def __init__(self, data_config=None, channels_first=False):
        super().__init__()
        self.file_name = None
        # `data_config` loads anything inside the `info` part of the `data` section. 
        if data_config is not None:
            # this example assumes the local dataset is in .npz format, so it searches for it.
            if 'npz_file' in data_config: 
                self.file_name = data_config['npz_file']
        self.channels_first = channels_first
        
        if self.file_name is None:
            raise FLException('No data file name is provided to load the dataset.')
        else:
            try:
                data_train = np.load(self.file_name)
                self.x_train = data_train['x_train']
                self.y_train = data_train['y_train']
                self.x_test = data_train['x_test']
                self.y_test = data_train['y_test']
            except Exception:
                raise IOError('Unable to load training data from path '
                              'provided in config file: ' +
                              self.file_name)
            self.preprocess_data()

    def get_data(self):
        """
        Gets pre-processed mnist training and testing data. 

        :return: training and testing data
        :rtype: `tuple`
        """
        return (self.x_train, self.y_train), (self.x_test, self.y_test)

    def preprocess_data(self):
        """
        Preprocesses the training and testing dataset.

        :return: None
        """
        num_classes = 10
        img_rows, img_cols = 28, 28
        if self.channels_first:
            self.x_train = self.x_train.reshape(self.x_train.shape[0], 1, img_rows, img_cols)
            self.x_test = self.x_test.reshape(self.x_test.shape[0], 1, img_rows, img_cols)
        else:
            self.x_train = self.x_train.reshape(self.x_train.shape[0], img_rows, img_cols, 1)
            self.x_test = self.x_test.reshape(self.x_test.shape[0], img_rows, img_cols, 1)

        print('x_train shape:', self.x_train.shape)
        print(self.x_train.shape[0], 'train samples')
        print(self.x_test.shape[0], 'test samples')

        # convert class vectors to binary class matrices
        self.y_train = np.eye(num_classes)[self.y_train]
        self.y_test = np.eye(num_classes)[self.y_test]

# XGBoost classification model
# you can choose your own loss function by changing the content for 'loss'. 
# In the following example, we choose `binary_crossentropy` 
# for a binary classification example.
# If you want to train a multiclass classification problem, you need to choose
# 'categorical_crossentropy'. 
# You can also choose 'auto' to allow IBM FL to choose the correct loss for you.

spec = {
	'global': {
            'learning_rate': 0.1,
            'loss': 'binary_crossentropy',
            'max_bins': 255,
            'max_depth': None,
            'max_iter': 100,
            'verbose': True,
            'num_classes': 2
        }
}

# XGBoost regression model
# you can choose your own loss function by changing the content for 'loss'. 
# In the following example, we choose `binary_crossentropy` 
# for a binary classification example.
# If you want to train a multiclass classification problem, you need to choose
# 'categorical_crossentropy'. 
# You can also choose 'auto' to allow IBM FL to choose the correct loss for you.

spec = {
	'global': {
            'learning_rate': 0.1,
            'loss': 'least_squares', 
            'max_bins': 255,
            'max_depth': None,
            'max_iter': 100,
            'verbose': True
        }
}

# SKLearn classification
# Specify your model. Users need to provide the classes used in classification problems.
# In the example, there are 10 classes.

model = SGDClassifier(loss='log', penalty='l2')
model.classes_ = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])  

# Define the path and save the model as a pickle file

if not os.path.exists(folder_configs):
    os.makedirs(folder_configs)
fname = os.path.join(folder_configs, 'model_architecture.pickle')
with open(fname, 'wb') as f:
    joblib.dump(model, f)
    # Generate model spec:
spec = {'model_definition': fname}

# Sklearn regression 
# create a sklearn regression model

model = SGDRegressor(loss='huber', penalty='l2')

# specify/create a directory where you want to save the model file

if not os.path.exists(folder_configs):
    os.makedirs(folder_configs)
fname = os.path.join(folder_configs, 'model_architecture.pickle')

# save the model as a pickle file

with open(fname, 'wb') as f:
    pickle.dump(model, f)

# SKLearn Kmeans

def get_model_config(folder_configs, dataset, is_agg=False, party_id=0):

    model = KMeans()

    # Save model
    fname = os.path.join(folder_configs, 'kmeans-central-model.pickle')
    with open(fname, 'wb') as f:
        pickle.dump(model, f)
    # Generate model spec:
    spec = {
        'model_name': 'sklearn-kmeans',
        'model_definition': fname
    }

    model = {
        'name': 'SklearnKMeansFLModel',
        'path': 'ibmfl.model.sklearn_kmeans_fl_model',
        'spec': spec
    }

    return model

img_rows, img_cols = 28, 28
    batch_size = 28
    input_shape = (batch_size, img_rows, img_cols, 1)
    sample_input = np.zeros(shape=input_shape)

    class MyModel(Model):
        def __init__(self):
            super(MyModel, self).__init__()
            self.conv1 = Conv2D(32, 3, activation='relu')
            self.flatten = Flatten()
            self.d1 = Dense(128, activation='relu')
            self.d2 = Dense(10)

        def call(self, x):
            x = self.conv1(x)
            x = self.flatten(x)
            x = self.d1(x)
            return self.d2(x)

    # Create an instance of the model
    model = MyModel()
    loss_object = tf.keras.losses.SparseCategoricalCrossentropy(
        from_logits=True)
    optimizer = tf.keras.optimizers.Adam()
    acc = tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy')
    model.compile(optimizer=optimizer, loss=loss_object, metrics=[acc])
    model._set_inputs(sample_input)

    if not os.path.exists(folder_configs):
        os.makedirs(folder_configs)

    model.save(folder_configs)

model = keras.Sequential([
   keras.layers.Dense(16, activation = 'relu', input_shape = (11,)),
   keras.layers.Dropout(0.5),
   keras.layers.Dense(1, activation = 'sigmoid')])
   model.compile(optimizer=keras.optimizers.Adam(lr=2e-2), loss=keras.losses.binary_crossentropy, metrics=metrics)
])