Question

我设法从给定的 CSV 文件加载了联合数据集，并且我正在尝试对可用数据执行一些联合学习。

我现在的问题是如何重现一个工作示例来构建一个迭代过程，该过程对这些数据执行自定义联合平均。

这个问题是上一个问题的续篇，此处Build Custom Federated averaging process with ValueError: Layer sequential expects 1 inputs, but it received 3 input tensors。（特别感谢@Zachary Garrett 帮助解决了之前的问题）。

这是我的代码，但它不起作用

import collections
import os

import numpy as np
import pandas as pd
import tensorflow as tf
import tensorflow_federated as tff
from absl import app
from tensorflow.keras import layers
from src.main.Utils import Util, StringBuilder
from src.main import Parameters
from src.main.federated.Model_State import ClientState
global input_spec
import random
def main(args):
    working_dir = "D:/User/Documents/GitHub/TriaBaseMLBackup/input/fakehdfs/nms/ystr=2016/ymstr=1/ymdstr=28"
    client_id_colname = 'counter'
    SHUFFLE_BUFFER = 1000
    NUM_EPOCHS = 1

    for root, dirs, files in os.walk(working_dir):
        file_list = []

        for filename in files:
            if filename.endswith('.csv'):
                file_list.append(os.path.join(root, filename))
        df_list = []
        for file in file_list:
            df = pd.read_csv(file, delimiter="|", usecols=[1, 2, 6, 7], header=None, na_values=["NIL"],
                             na_filter=True, names=["time", "meas_info", "counter", "value"],encoding='latin-1')
            # df_list.append(df[["value"]])

        if df_list:
            rawdata = pd.concat(df_list)

    #print(df.head())
    client_ids = df.get(client_id_colname)
    train_client_ids = client_ids.sample(frac=0.5).tolist()
    #test_client_ids = [x for x in client_ids if x not in train_client_ids]
    # test_client_ids = [x for x in client_ids if x not in train_client_ids]

    def create_tf_dataset_for_client_fn(client_id):
        # a function which takes a client_id and returns a
        # tf.data.Dataset for that client
        # target = df.pop('value')
        client_data = df[df['value'] == client_id]
        #print(df.head())
        features = ['time', 'meas_info', 'value']
        LABEL_COLUMN = 'counter'
        dataset = tf.data.Dataset.from_tensor_slices(
            (collections.OrderedDict(client_data[features].to_dict('list')),
             client_data[LABEL_COLUMN].to_list())
        )
        global input_spec
        input_spec = dataset.element_spec
        dataset = dataset.shuffle(SHUFFLE_BUFFER).batch(1).repeat(NUM_EPOCHS)
        return dataset

    train_data = tff.simulation.ClientData.from_clients_and_fn(
        client_ids=train_client_ids,
        create_tf_dataset_for_client_fn=create_tf_dataset_for_client_fn
    )
   # test_data = tff.simulation.ClientData.from_clients_and_fn(
    #    client_ids=test_client_ids,
    #    create_tf_dataset_for_client_fn=create_tf_dataset_for_client_fn
    #)
    example_dataset = train_data.create_tf_dataset_for_client(
        train_data.client_ids[0]
    )

    # split client id into train and test clients
    loss_builder = tf.keras.losses.SparseCategoricalCrossentropy
    metrics_builder = lambda: [tf.keras.metrics.SparseCategoricalAccuracy()]

    def retrieve_model():
        SEQUENCE_LENGTH = 5
        features = ['time', 'meas_info', 'value']
        input_dict = {f: tf.keras.layers.Input(shape=(SEQUENCE_LENGTH, 1), name=f) for f in features}
        concatenated_inputs = tf.keras.layers.Concatenate()(input_dict.values())
        lstm_output = tf.keras.layers.LSTM(2, input_shape=(1, 2), return_sequences=True)(concatenated_inputs)
        logits = tf.keras.layers.Dense(256, activation=tf.nn.relu)(lstm_output)
        predictions = tf.keras.layers.Activation(tf.nn.softmax)(logits)
        model = tf.keras.models.Model(inputs=input_dict, outputs=predictions)
        return model

    print(input_spec)

    def tff_model_fn() -> tff.learning.Model:
        return tff.learning.from_keras_model(
            keras_model=retrieve_model(),
            input_spec=example_dataset.element_spec,
            loss=loss_builder(),
            metrics=metrics_builder())

    iterative_process = tff.learning.build_federated_averaging_process(
        tff_model_fn, Parameters.server_adam_optimizer_fn, Parameters.client_adam_optimizer_fn)
    server_state = iterative_process.initialize()
   
    for round_num in range(Parameters.FLAGS.total_rounds):
        sampled_clients = np.random.choice(
            train_data.client_ids,
            size=Parameters.FLAGS.train_clients_per_round,
            replace=False)
        sampled_train_data = [
            train_data.create_tf_dataset_for_client(client)
            for client in sampled_clients
        ]
        server_state, metrics = iterative_process.next(server_state, sampled_train_data)
        #train_metrics = metrics['train']
        print('round {:2d}, metrics={}'.format(round_num, metrics))
        #broadcasted_bits, aggregated_bits = evaluate(round_num, train_metrics, server_state, model, environment, metric, str_acc, str_loss)

这是 input_spec 输出：

(OrderedDict([('time', TensorSpec(shape=(), dtype=tf.int32, name=None)), ('meas_info', TensorSpec(shape=(), dtype=tf.int32, name=None)), ('value', TensorSpec(shape=(), dtype=tf.int64, name=None))]), TensorSpec(shape=(), dtype=tf.float32, name=None))

这是我得到的错误：

ValueError: Input 0 of layer lstm is incompatible with the layer: expected ndim=3, found ndim=1. Full shape received: [None]

任何人都可以根据我的案例帮助重现一个工作示例吗？

Build Custom Federated learning ValueError: Input 0 of layer lstm is incompatible with the layer: expected ndim=3, found ndim=1

0 个答案: