Zusätzliche Details für die Implementierung von Federated Learning

# Umgebung erstellen
conda create -n fl_env python=3.7.9

# Jupyter in Umgebung erstellen
conda install -c conda-forge -n fl_env notebook

# Umgebung aktivieren
conda activate fl_env

# pip-Installation von SDK
pip install ibm-watson-machine-learning

# pip-Installation von Paketen, die von IBMFL benötigt werden
pip install environs parse websockets jsonpickle pandas pytest pyYAML requests pathlib2 psutil setproctitle tabulate lz4 opencv-python gym ray==0.8.0 cloudpickle==1.3.0 image

# pip-Installation von Frameworks, die von IBMFL verwendet werden
pip install tensorflow==2.1.0 scikit-learn==0.23.1 keras==2.2.4 numpy==1.17.4 scipy==1.4.1

# Juypyter-Notebooks starten
jupyter notebook  # <-- Sicherstellen, dass die Umgebung bereits aktiviert wurde: conda activate fl_env

train_gen = ImageDataGenerator(rotation_range=8,
                                width_shift_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

# Import von ibmfl
from ibmfl.data.data_handler import DataHandler
from ibmfl.exceptions import FLException



class MnistKerasDataHandler(DataHandler):
    """
    Datenhandler für MNIST-Dataset.
    """

    def __init__(self, data_config=None, channels_first=False):
        super().__init__()
        self.file_name = None
        # `data_config` lädt alles im Teil `info` des Abschnitts `data`.
        if data_config is not None:
            # Bei diesem Beispiel wird angenommen, dass das lokale Dataset im .npz-Format vorliegt, also wird danach gesucht.
            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):
        """
        Ruft vorverarbeitete MNIST-Trainings- und Testdaten ab.

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

    def preprocess_data(self):
        """
        Vorverarbeitung des Trainings- und Testdatasets.

        :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')

        # Konvertiert Klassenvektoren zu binären Klassenmatrizen
        self.y_train = np.eye(num_classes)[self.y_train]
        self.y_test = np.eye(num_classes)[self.y_test]

# XGBoost-Klassifikationsmodell
# Sie können Ihre eigene Verlustfunktion wählen, indem Sie den Inhalt für 'loss' ändern.
# Im folgenden Beispiel wird `binary_crossentropy` als Beispiel
# für eine binäre Klassifikation ausgewählt.
# Wenn Sie ein Problem für eine Klassifikation mehrerer Klassen trainieren möchten, müssen Sie
# 'categorical_crossentropy' auswählen.
# Sie können auch 'auto' auswählen, damit IBM FL den richtigen Verlust für Sie auswählt.

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

# XGBoost-Regressionsmodell
# Sie können Ihre eigene Verlustfunktion wählen, indem Sie den Inhalt für 'loss' ändern.
# Im folgenden Beispiel wird `binary_crossentropy` als Beispiel
# für eine binäre Klassifikation ausgewählt.
# Wenn Sie ein Problem für eine Klassifikation mehrerer Klassen trainieren möchten, müssen Sie
# 'categorical_crossentropy' auswählen.
# Sie können auch 'auto' auswählen, damit IBM FL den richtigen Verlust für Sie auswählt.

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

# SKLearn -Klassifikation
# Geben Sie Ihr Modell an. Benutzer müssen die Klassen angeben, die bei Klassifikationsproblemen verwendet werden.
# In dem vorliegendenBeispiel gibt es 10 Klassen.

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

# Definieren Sie den Pfad und speichern Sie das Modell als eine Pickle-Datei

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
# Erstellen Sie ein SKlearn-Regressionsmodell

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

# Geben SieeinVerzeichnis an bzw. erstellen Sie eines, in dem die Modelldatei gespeichert werden soll .

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

# Speichern Sie das Modell als Pickle-Datei

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

# SKLearn K-Means

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

    model = KMeans()

    # Speichern Sie das Modell
    fname = os.path.join(folder_configs, 'kmeans-central-model.pickle')
    with open(fname, 'wb') as f:
        pickle.dump(model, f)
    # Generieren Sie eine Modellspezifikation:
    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)

    # Erstellen Sie eine Instanz des Modells
    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)
])