Federated Learning with TensorFlow: A Practical Guide with Example Code

In this blog “Federated Learning with Tensorflow: A Practical Guide with Example Code”, we will delve into the concept of Federated Learning and demonstrate how it can be implemented with Tensorflow. We will provide a comprehensive, step-by-step guide to building a Federated Learning model, accompanied by a detailed explanation of the code used throughout the process.

The increasing significance of data privacy and security has led many organizations to be cautious about sharing their data with third-party vendors or cloud providers. Federated Learning is a novel technology that enables organizations to train machine learning models without exposing their data to others.

What is Federated Learning?

Federated Learning is a distributed machine learning approach that facilitates the training of models across numerous devices or servers without the necessity of transmitting data to a central location. Rather than sending data to a central server for processing, Federated Learning enables the model to be trained locally on each device. Only the updated model parameters are forwarded to the central server. This approach guarantees that the data remains on the device, thereby ensuring data privacy and security.

Federated Learning with Tensorflow

TensorFlow is an open-source machine learning framework that provides tools for building and training machine learning models. It also supports Federated Learning through its TensorFlow Federated (TFF) library. TFF allows developers to build and deploy Federated Learning models using a high-level programming interface. By leveraging federated learning with Tensorflow, organizations can build AI systems that deliver valuable insights while maintaining the privacy of sensitive data.

Let’s look at an example of building a Federated Learning model using Tensorflow.

Example: Federated Learning with Tensorflow (for Image Classification)

In this example, we’ll build a Federated Learning model for image classification using the MNIST dataset. We’ll use a simple Convolutional Neural Network (CNN) as our model architecture.

  • Import the necessary libraries

First, we’ll import the necessary libraries, including Tensorflow and TFF:

import tensorflow as tf
import tensorflow_federated as tff
  • Load the MNIST dataset

Next, we’ll load the MNIST dataset:

mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
  • Define the model architecture

We’ll define a simple CNN for image classification:

def create_model():
  model = tf.keras.models.Sequential([
      tf.keras.layers.Reshape(input_shape=(28,28,1), target_shape=(28,28,1)),
      tf.keras.layers.Conv2D(filters=32, kernel_size=(3,3), activation='relu'),
      tf.keras.layers.Dense(10, activation='softmax')
  return model

This code defines a function called create_model() that returns a simple convolutional neural network (CNN) model for image classification.

The model architecture includes the following layers:

  1. Reshape: This layer changes the input shape of the image from (28, 28, 1) to (28, 28, 1).
  2. Conv2D: This is a 2D convolutional layer with 32 filters and a kernel size of (3, 3). It applies the ReLU activation function to the output of the convolution operation.
  3. MaxPooling2D: This is a 2D max pooling layer with a pool size of (2, 2).
  4. Flatten: This layer flattens the output of the previous layer into a 1D array.
  5. Dense: This is a fully connected layer with 10 neurons, which corresponds to the 10 classes in the MNIST dataset. It applies the softmax activation function to the output of the layer.

The create_model() function returns the model object, which can be used to create a Federated Learning model using the from_keras_model() method from the TensorFlow Federated library.

  • Create a Federated Learning model

We’ll create a Federated Learning model using the TFF library:

def create_federated_model():
  return tff.learning.from_keras_model(
      input_spec=tf.TensorSpec(shape=(None, 28, 28, 1), dtype=tf.float32),

This code snippet defines a function create_federated_model() that creates a Federated Learning model using the TFF library. The from_keras_model() function from TFF is used to convert the Keras model created in the previous step into a Federated Learning model.

The keras_model argument specifies the Keras model to be converted, which in this case is the model returned by create_model(). The input_spec argument specifies the shape and data type of the input data. In this example, the input data has a shape of (None, 28, 28, 1) and a data type of tf.float32, which represents the grayscale images in the MNIST dataset.

The loss argument specifies the loss function to be used during training, which is the SparseCategoricalCrossentropy() function. This function is commonly used for classification problems with sparse labels, such as the MNIST dataset.

The metrics argument specifies the evaluation metrics to be used during training, which in this case is the SparseCategoricalAccuracy() function. This function computes the accuracy of the model predictions compared to the true labels.

Overall, this function creates a Federated Learning model that is based on the Keras model architecture defined earlier, and specifies the necessary parameters for training the model with Federated Learning using the TFF library.

  • Define the Federated Learning process

We’ll define the Federated Learning process using the TFF library:

federated_train_data = [x_train[i:i+100], y_train[i:i+100]] for i in range(0, len(x_train), 100)]
federated_train_data = [tf.data.Dataset.from_tensor_slices((x, y)).batch(20) for x, y in federated_train_data]

def federated_train(model, federated_train_data):
  return tff.learning.build_federated_averaging_process(
      model_fn=lambda: model,
      client_optimizer_fn=lambda: tf.keras.optimizers.SGD(learning_rate=0.02),
      server_optimizer_fn=lambda: tf.keras.optimizers.SGD(learning_rate=1.0),

This code defines two functions related to the Federated Learning process: federated_train_data and federated_train.

The first line of code creates a list of tuples federated_train_data, where each tuple contains a batch of 100 training examples and their corresponding labels. The range() function is used to iterate over the training data in batches of 100, and each batch is extracted from the x_train and y_train arrays.

The second line of code converts each tuple in federated_train_data into a tf.data.Dataset object using the from_tensor_slices() function. The batch() function is also called to group the data into batches of size 20. This creates a list of federated datasets that can be used for Federated Learning.

The federated_train() function is used to train the Federated Learning model using the TFF library. It calls the build_federated_averaging_process() function, which is a high-level API provided by TFF for training Federated Learning models.

The model_fn argument specifies the model architecture, which is the model argument passed to the function. The client_optimizer_fn and server_optimizer_fn arguments specify the optimization algorithms to be used for training the client models and the server model, respectively. In this example, we use stochastic gradient descent (SGD) with a learning rate of 0.02 for the client optimizer and a learning rate of 1.0 for the server optimizer.

The client_weight_fn argument specifies the weighting to be applied to each client during training, which is set to None in this example.

Finally, the federated_train_data argument is passed to the build_federated_averaging_process() function to train the Federated Learning model. This function returns a Federated Averaging Process that can be used to train the model on a distributed set of devices.

  • Train the Federated Learning model

We’ll now train the Federated Learning model using the federated_train function:

iterative_process = federated_train(create_federated_model(), federated_train_data)
for round_num in range(10):
  state = iterative_process.next(state)
  print('Round {}: loss={}'.format(round_num, state['loss']))

This code defines an iterative process to train the Federated Learning model. The federated_train() function is called to create an initial Federated Averaging Process using the create_federated_model() function and the federated_train_data list of federated datasets.

In the for loop, the next() method is called on the iterative_process object for a specified number of rounds. This method takes a state argument, which represents the current state of the Federated Learning process. The next() method returns an updated state object that contains the updated model parameters and the training loss for the current round.

In each iteration of the loop, the current round number and training loss are printed to the console using the print() function. The format() method is used to insert the round number and loss value into the printed string.

The loop continues for a specified number of rounds, which is set to 10 in this example. This allows the Federated Learning model to be trained on the distributed set of devices over multiple rounds, with the model parameters being updated at each round using the Federated Averaging Process. Federated learning with Tensorflow is becoming increasingly popular as more organizations recognize the benefits of decentralized data training and collaborative learning. Hope liked our attempt to showcase Federated Learning with TensorFlow.


In summary, this blog post “Federated Learning with Tensorflow” has covered the concept of Federated Learning and provided a practical example of how to implement it using TensorFlow. Specifically, we have created a Federated Learning model for image classification using the MNIST dataset and explained the code step by step.

Federated Learning has emerged as a promising solution to address concerns around data privacy and security in machine learning. By allowing the training of models on local devices without sharing the data, Federated Learning offers a new approach to machine learning that can benefit a wide range of applications. With the help of libraries such as TensorFlow Federated, developers can easily create and deploy Federated Learning models and explore the full potential of this exciting technology.

You may also like:

Check out the table of contents for Product Management and Data Science to explore these topics further.

Curious about how product managers can utilize Bhagwad Gita’s principles to tackle difficulties? Give this super short book a shot. This will certainly support my work.

Leave a Reply