fedML_demo.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ma10s\\Anaconda3\\lib\\site-packages\\h5py\\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from __future__ import print_function\n",
    "import keras\n",
    "from keras.datasets import cifar10\n",
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout, Activation, Flatten, BatchNormalization\n",
    "from keras.layers import Conv2D, MaxPooling2D\n",
    "import os\n",
    "\n",
    "\n",
    "batch_size = 32\n",
    "num_classes = 10\n",
    "epochs = 100\n",
    "data_augmentation = True\n",
    "num_predictions = 20\n",
    "save_dir = os.path.join(os.getcwd(), 'saved_models')\n",
    "model_name = 'keras_cifar10_trained_model.h5'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_train shape: (50000, 32, 32, 3)\n",
      "50000 train samples\n",
      "10000 test samples\n"
     ]
    }
   ],
   "source": [
    "# The data, split between train and test sets:\n",
    "\n",
    "(x_train, y_train), (x_test, y_test) = cifar10.load_data()\n",
    "print('x_train shape:', x_train.shape)\n",
    "print(x_train.shape[0], 'train samples')\n",
    "print(x_test.shape[0], 'test samples')\n",
    "\n",
    "# Convert class vectors to binary class matrices.\n",
    "y_train = keras.utils.to_categorical(y_train, num_classes)\n",
    "y_test = keras.utils.to_categorical(y_test, num_classes)\n",
    "x_train = x_train.astype('float32')\n",
    "x_test = x_test.astype('float32')\n",
    "x_train /= 255\n",
    "x_test /= 255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ANN_model():\n",
    "    model = Sequential()\n",
    "    model.add(Conv2D(32, (3, 3), padding='same',\n",
    "                     input_shape=x_train.shape[1:]))\n",
    "    model.add(Activation('relu'))\n",
    "    model.add(Conv2D(32, (3, 3)))\n",
    "    model.add(Activation('relu'))\n",
    "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "    model.add(Dropout(0.25))\n",
    "\n",
    "    model.add(Conv2D(64, (3, 3), padding='same'))\n",
    "    model.add(Activation('relu'))\n",
    "    model.add(Conv2D(64, (3, 3)))\n",
    "    model.add(Activation('relu'))\n",
    "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "    model.add(Dropout(0.25))\n",
    "\n",
    "    model.add(Flatten())\n",
    "    model.add(Dense(512))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation('relu'))\n",
    "    model.add(Dropout(0.5))\n",
    "    model.add(Dense(100))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation('relu'))\n",
    "    model.add(Dropout(0.5))\n",
    "    model.add(Dense(num_classes))\n",
    "    model.add(Activation('softmax'))\n",
    "\n",
    "    # initiate RMSprop optimizer\n",
    "    opt = keras.optimizers.Adam(learning_rate=0.001, decay=1e-6)\n",
    "\n",
    "    # Let's train the model using RMSprop\n",
    "    model.compile(loss='categorical_crossentropy',\n",
    "                  optimizer=opt,\n",
    "                  metrics=['accuracy'])\n",
    "    return model\n",
    "\n",
    "def train_model(model, x_train, y_train, x_test, y_test, epochs, save_as=\"cifarmodel\"):\n",
    "    \n",
    "    mcp_save = keras.callbacks.ModelCheckpoint(save_as+'.hdf5',\n",
    "                                                       save_best_only=True, \n",
    "                                                       monitor='val_loss', \n",
    "                                                       mode='min')\n",
    "    if not data_augmentation:\n",
    "        print('Not using data augmentation.')\n",
    "        model.fit(x_train, y_train,\n",
    "                  batch_size=batch_size,\n",
    "                  epochs=epochs,\n",
    "                  validation_data=(x_test, y_test),\n",
    "                  shuffle=True, \n",
    "                  callbacks=[mcp_save])\n",
    "    else:\n",
    "        print('Using real-time data augmentation.')\n",
    "        # This will do preprocessing and realtime data augmentation:\n",
    "        datagen = ImageDataGenerator(\n",
    "            featurewise_center=False,  # set input mean to 0 over the dataset\n",
    "            samplewise_center=False,  # set each sample mean to 0\n",
    "            featurewise_std_normalization=False,  # divide inputs by std of the dataset\n",
    "            samplewise_std_normalization=False,  # divide each input by its std\n",
    "            zca_whitening=False,  # apply ZCA whitening\n",
    "            zca_epsilon=1e-06,  # epsilon for ZCA whitening\n",
    "            rotation_range=0,  # randomly rotate images in the range (degrees, 0 to 180)\n",
    "            # randomly shift images horizontally (fraction of total width)\n",
    "            width_shift_range=0.1,\n",
    "            # randomly shift images vertically (fraction of total height)\n",
    "            height_shift_range=0.1,\n",
    "            shear_range=0.,  # set range for random shear\n",
    "            zoom_range=0.,  # set range for random zoom\n",
    "            channel_shift_range=0.,  # set range for random channel shifts\n",
    "            # set mode for filling points outside the input boundaries\n",
    "            fill_mode='nearest',\n",
    "            cval=0.,  # value used for fill_mode = \"constant\"\n",
    "            horizontal_flip=True,  # randomly flip images\n",
    "            vertical_flip=False,  # randomly flip images\n",
    "            # set rescaling factor (applied before any other transformation)\n",
    "            rescale=None,\n",
    "            # set function that will be applied on each input\n",
    "            preprocessing_function=None,\n",
    "            # image data format, either \"channels_first\" or \"channels_last\"\n",
    "            data_format=None)#,\n",
    "            # fraction of images reserved for validation (strictly between 0 and 1)\n",
    "            #validation_split=0.0)\n",
    "\n",
    "        # Compute quantities required for feature-wise normalization\n",
    "        # (std, mean, and principal components if ZCA whitening is applied).\n",
    "        datagen.fit(x_train)\n",
    "\n",
    "        # Fit the model on the batches generated by datagen.flow().\n",
    "        history = model.fit_generator(datagen.flow(x_train, y_train,\n",
    "                                         batch_size=batch_size),\n",
    "                            epochs=epochs,\n",
    "                            #validation_data=(x_test, y_test),\n",
    "                            workers=4)#,\n",
    "                            #callbacks=[mcp_save])\n",
    "\n",
    "        # # Save model and weights\n",
    "        # if not os.path.isdir(save_dir):\n",
    "        #     os.makedirs(save_dir)\n",
    "        # model_path = os.path.join(save_dir, model_name)\n",
    "        # model.save(model_path)\n",
    "        # print('Saved trained model at %s ' % model_path)\n",
    "        \n",
    "        # Load best model version from training\n",
    "        model = keras.models.load_model(save_as+'.hdf5')\n",
    "        # Score trained model.\n",
    "        scores = model.evaluate(x_test, y_test, verbose=1)\n",
    "        print('Test loss:', scores[0])\n",
    "        print('Test accuracy:', scores[1])\n",
    "        return history.history, scores\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = ANN_model()\n",
    "hist, scores = train_model(model, x_train, y_train, x_test, y_test,epochs=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_train shape:  (50000, 32, 32, 3)\n",
      "x_train_splits shape:  (31250, 32, 32, 3)\n",
      "x_train_splits shape:  (15625, 32, 32, 3)\n",
      "x_train_splits shape:  (3125, 32, 32, 3)\n",
      "tot len:  50000\n"
     ]
    }
   ],
   "source": [
    "from fedml import Alliance, AllianceMember,KerasSequentialBaseLearner, FedAveragingClassifier\n",
    "from read_data import read_training_data\n",
    "import numpy as np\n",
    "\n",
    "alliance = Alliance()\n",
    "M=10\n",
    "def split_data(x,y,fractions):\n",
    "    s = len(x)\n",
    "    new_order = np.random.permutation(s)\n",
    "    x = x[new_order]\n",
    "    y = y[new_order]\n",
    "    if type(fractions) is int:\n",
    "        fraction_splits = np.int32(np.linspace(0,s,fractions+1))\n",
    "        nr = fractions\n",
    "    elif type(fractions)==np.ndarray or type(fractions)==list:\n",
    "        parts = np.array(fractions)*s/np.sum(fractions)\n",
    "        fraction_splits = np.int32([np.sum(parts[:i]) for i in range(len(parts)+1)])\n",
    "        nr = len(parts)\n",
    "        \n",
    "    x_list = []\n",
    "    y_list = []\n",
    "    for i in range(nr):\n",
    "        x_list.append(x[fraction_splits[i]:fraction_splits[i+1]]) \n",
    "        y_list.append(y[fraction_splits[i]:fraction_splits[i+1]])\n",
    "\n",
    "    return x_list,y_list\n",
    "F = [10,5,1]\n",
    "M = len(F)\n",
    "x_train_splits, y_train_splits = split_data(x_train,y_train,fractions=F)\n",
    "x_test_splits, y_test_splits = split_data(x_test,y_test,fractions=F)\n",
    "print(\"x_train shape: \", np.array(x_train).shape)\n",
    "tot_len = 0\n",
    "for split in x_train_splits:\n",
    "    print(\"x_train_splits shape: \", split.shape)\n",
    "    tot_len += len(split)\n",
    "print(\"tot len: \", tot_len)\n",
    "classes = np.arange(10)\n",
    "for i in range(M):\n",
    "    member = AllianceMember(x_train_splits[i], y_train_splits[i], classes=classes)\n",
    "    alliance.add_member(member)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cifarmodel import KerasSequentialCifar\n",
    "\n",
    "base_learner = KerasSequentialCifar()\n",
    "fedavg_model = FedAveragingClassifier(alliance=alliance,base_learner=base_learner)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parameters = {\"nr_global_iterations\": 100, \"nr_local_iterations\":1} \n",
    "training_loss, test_loss = fedavg_model.fit(parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}