在运行“构建您自己的联邦学习算法”教程时，Tensorflow federated ( TFF ) 0.19的性能明显低于TFF 0.17

Question

在最后的“构建您自己的联邦学习算法”教程中指出，在训练我们的模型15轮之后，我们将期望在0.25左右运行一个sparse_categorical_accuracy，但是在colab中运行该教程将给出一个基于我运行的结果在0.09到0.11之间。然而，只需将tf和tff版本分别更改为2.3.x和0.17，就会得到0.25左右的结果，就像我们预期的那样！

要按原样运行上述教程，应该使用tf 2.5和tff 0.19。之后，只需简单地更改

!pip install --quiet --upgrade tensorflow-federated

至

!pip install --quiet tensorflow==2.3.0
!pip install --quiet --upgrade tensorflow-federated==0.17.0

另外，tf 2.4和tff 0.18组合工作得很好，得分在0.25左右。因此，只有tf 2.5和tff 0.19组合并不能给出预期的结果。

我要明确的是，我并不是说第一次设置并不能训练模型；200轮运行表明，得分稳步提高，达到了0.7到0.8。我希望能澄清为什么会这样，或者如果我做错了什么，请指出。

编辑：为了确保在不同的tff版本中使用相同的客户端，我使用了以下代码

用于培训数据

sorted_client_ids = sorted(emnist_train.client_ids)
sorted_client_ids2 = sorted_client_ids[0:10]

federated_train_data = [preprocess(emnist_train.create_tf_dataset_for_client(x))
                       for x in sorted_client_ids2]

用于测试数据

sorted_client_ids = sorted(emnist_test.client_ids)
sorted_client_ids2 = sorted_client_ids[0:100]

def data(client, source=emnist_test):
    return preprocess(source.create_tf_dataset_for_client(client))

central_emnist_test = (tf.data.Dataset.from_tensor_slices(
    [data(client) for client in sorted_client_ids2])).flat_map(lambda x: x)

我训练了50发子弹。我在这些设置中得到的结果是

1.8676 - sparse_categorical_accuracy: 0.5115

0.18:损失: 1.8503 - sparse_categorical_accuracy: 0.5160

0.19:损失: 2.2007 - sparse_categorical_accuracy: 0.1014

因此，我的问题是，三个版本的tff都使用了相同的训练数据、相同的测试数据，模型具有相同的初始化和相同的训练轮，但tff 0.19和tff 0.18/0.17的结果相差很大，而tff 0.18和0.17的结果非常相似。

再一次，为了澄清tff 0.19也提高了它的准确性，但程度要小得多。

编辑2:遵循Zachary Charles的建议，我使用了联邦sgd。对于tff 0.18和0.17，请编辑第一行。

!pip install --quiet --upgrade tensorflow-federated
!pip install --quiet --upgrade nest-asyncio

import nest_asyncio
nest_asyncio.apply()

import collections
import attr
import functools
import numpy as np
import tensorflow as tf
import tensorflow_federated as tff

np.random.seed(0)

print(tf.__version__)
print(tff.__version__)

emnist_train, emnist_test = tff.simulation.datasets.emnist.load_data()

NUM_CLIENTS = 10
BATCH_SIZE = 20

def preprocess(dataset):
    def batch_format_fn(element):
        return(tf.reshape(element['pixels'],[-1,784]),
              tf.reshape(element['label'],[-1,1]))
    return dataset.batch(BATCH_SIZE).map(batch_format_fn)

sorted_client_ids = sorted(emnist_train.client_ids)
sorted_client_ids2 = sorted_client_ids[0:10]

federated_train_data = [preprocess(emnist_train.create_tf_dataset_for_client(x))
                       for x in sorted_client_ids2]

def create_keras_model():
    return tf.keras.models.Sequential([
        tf.keras.layers.InputLayer(input_shape=(784,)),
        tf.keras.layers.Dense(10, kernel_initializer='zeros'),
        tf.keras.layers.Softmax(),
    ])

def model_fn():
    keras_model = create_keras_model()
    return tff.learning.from_keras_model(
        keras_model,
        input_spec=federated_train_data[0].element_spec,
        loss=tf.keras.losses.SparseCategoricalCrossentropy(),
        metrics=[tf.keras.metrics.SparseCategoricalAccuracy()])
    
sorted_client_ids = sorted(emnist_test.client_ids)
sorted_client_ids2 = sorted_client_ids[0:10]

def data(client, source=emnist_test):
    return preprocess(source.create_tf_dataset_for_client(client))

central_emnist_test = (tf.data.Dataset.from_tensor_slices(
    [data(client) for client in sorted_client_ids2])).flat_map(lambda x: x)

def evaluate(server_state):
    keras_model = create_keras_model()
    keras_model.compile(
      loss=tf.keras.losses.SparseCategoricalCrossentropy(),
      metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]  
    )
    keras_model.set_weights(server_state)
    keras_model.evaluate(central_emnist_test)


iterative_process = tff.learning.build_federated_sgd_process(
    model_fn,
    server_optimizer_fn=lambda: tf.keras.optimizers.SGD(learning_rate=0.01))

state = iterative_process.initialize()
evaluate(state.model.trainable)

for round in range(50):
    print(round)
    state,_ = iterative_process.next(state, federated_train_data)

evaluate(state.model.trainable)

我得到的结果是

训练前

• 损失: 2.3026 - sparse_categorical_accuracy: 0.1207
• 0.18法郎:损失: 2.3026 - sparse_categorical_accuracy: 0.1010
• 2.3026 - sparse_categorical_accuracy: 0.1207

训练后

• 损失: 2.2122 - sparse_categorical_accuracy: 0.1983
• 0.18法郎:损失: 2.2158 - sparse_categorical_accuracy: 0.1700
• 2.2122 - sparse_categorical_accuracy: 0.1983

Answer 1

TFF 0.19将提供的数据集(包括教程中使用的EMNIST )从HDF5 5支持的实现移到了SQL支持的实现(提交)。这可能改变了客户机的顺序，这将改变教程中用于培训的客户端。

值得注意的是，在大多数模拟中，这不应该改变任何事情。客户端通常应该在每一轮随机抽样(这在本教程中由于阐述的原因而没有进行)，一般至少应该进行100轮(正如您所说的)。

我将更新本教程，通过对客户端in进行排序，然后按顺序选择它们，从而保证可再现性。

对于任何感兴趣的人，更好的做法是：( a)对客户端in进行排序，然后使用类似于np.random.RandomState的示例，如下所示：

emnist_train, _ = tff.simulation.datasets.emnist.load_data()
random_state = np.random.RandomState(seed=1729)
sorted_client_ids = sorted(emnist_train.client_ids)
sampled_client_ids = random_state.choice(sorted_client_ids, size=NUM_CLIENTS)