Build Type	Status	Artifacts
Linux CPU		PyPI
Linux GPU		PyPI
Linux XLA		TBA
macOS		PyPI
Windows CPU		PyPI
Windows GPU		PyPI
Android		Download
Raspberry Pi 0 and 1		Py3
Raspberry Pi 2 and 3		Py3
Libtensorflow MacOS CPU	Status Temporarily Unavailable	Nightly Binary Official GCS
Libtensorflow Linux CPU	Status Temporarily Unavailable	Nightly Binary Official GCS
Libtensorflow Linux GPU	Status Temporarily Unavailable	Nightly Binary Official GCS
Libtensorflow Windows CPU	Status Temporarily Unavailable	Nightly Binary Official GCS
Libtensorflow Windows GPU	Status Temporarily Unavailable	Nightly Binary Official GCS

install and import problem

I have followed the install steps
virtualenv --python python3 "venv" source ./venv/bin/activate pip install --upgrade pip (veno) pip install --upgrade tensorflow_federated
and I have installed bazel 0.23.2
when testing python -c "import tensorflow_federated as tff; tff.federated_computation(lambda: 'Hello, World!')()" it returned bash: !': event not found

when testing the demo, it shows error import tensorflow_federated as tff

Multiple inputs with keras model?

I'm trying to apply federated learning to an existing keras model that takes two inputs. When I call tff.learning.from_compiled_keras_model and include a dummy batch, I get this error: ValueError: Layer model_1 expects 2 inputs, but it received 1 input tensors. Inputs received: [<tf.Tensor 'packed:0' shape=(2, 20) dtype=int64>].

The model accepts two numpy arrays as inputs, so I defined my dummy_batch as:

x = tf.constant(np.random.randint(1,100, size=[20]))
collections.OrderedDict([('x', [x, x]), ('y', x)])

I dug around a little bit and saw that eventually, tf.convert_to_tensor_or_sparse_tensor gets called on the input list (in the __init__ for _KerasModel), and that returns a single tensor of shape (2,20), instead of two separate arrays or tensors. Is there some other way I can represent the list of inputs to avoid this issue?

Cannot use GPU to train in 0.5.0

My enviroment :
RedHat Linux 7.2
gcc 4.8.5
nvidia-driver : 410.48
cuda : 10.0
cudnn: 7.5
python2.7.5
tf-nightly-gpu==1.14.1-dev20190604
tensorflow_federated==0.5.0

When I use the example: federated_learning_for_image_classification.ipynb.
I change the model
model = tf.keras.models.Sequential([ tf.keras.layers.Dense( 10, activation=tf.nn.softmax, kernel_initializer='zeros', input_shape=(784,))])
to like this below:
model = tf.keras.models.Sequential([ tf.keras.layers.Reshape(target_shape=[28, 28, 1], input_shape=(28 * 28,)), tf.keras.layers.Conv2D( 32, 5, padding='same', activation=tf.nn.relu), tf.keras.layers.MaxPooling2D((2, 2), (2, 2), padding='same'), tf.keras.layers.Conv2D( 64, 5, padding='same', activation=tf.nn.relu), tf.keras.layers.MaxPooling2D((2, 2), (2, 2), padding='same'), tf.keras.layers.Flatten(), tf.keras.layers.Dense( 10, activation=tf.nn.softmax, kernel_initializer='zeros') ])
It show
MaxPoolingOp only support NHWC on device type cpu.
When I comment the all MaxPooling2D layer,
it also show the similar but more confuse problem:
Conv2DCustomBackprofFilterOp only supports NHWC.

I only change the model.
And I run this code in tf-nightly==1.14.1-dev20190604 (cpu versoin) it is fine.

Can anyone help?
Thanks

Installing with pip breaks because TF2.0 doesn't have contrib

Currently you cannot install by:
pip install --upgrade tensorflow-federated
because it will download tf 2.0 which doesn't have a contrib module. You have to pip install a fixed version<2.0 (it works with 1.13.1 for instance).

machine learning

Hello, there exists an example of a machine learning model? How do I use tff to deploy my own machine learning model? Thank you！

tff tutorial notebooks are broken

For text generation, it would stuck on

#@test {"output": "ignore"}
iterative_process = tff.learning.build_federated_averaging_process(model_fn)

with error message

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-15-0fdb188570d0> in <module>()
----> 1 iterative_process = tff.learning.build_federated_averaging_process(model_fn)

17 frames
/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/util/deprecation_wrapper.py in __getattr__(self, name)
    102     if name.startswith('_dw_'):
    103       raise AttributeError('Accessing local variables before they are created.')
--> 104     attr = getattr(self._dw_wrapped_module, name)
    105     if (self._dw_warning_count < _PER_MODULE_WARNING_LIMIT and
    106         name not in self._dw_deprecated_printed):

AttributeError: module 'tensorflow._api.v1.data.experimental' has no attribute 'NestedStructure'

However on my machine the error is different, I can build the averaging process, but would stuck on the next step:

state = fed_avg.initialize()
state, metrics = fed_avg.next(state, [example_dataset.take(1)])
print(metrics)

with error message

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-20-aa5f31726a7a> in <module>
      1 state = fed_avg.initialize()
----> 2 state, metrics = fed_avg.next(state, [example_dataset.take(1)])
      3 print(metrics)

~\Anaconda3\envs\tff\lib\site-packages\tensorflow_federated\python\core\impl\function_utils.py in __call__(self, *args, **kwargs)
    628   def __call__(self, *args, **kwargs):
    629     context = self._context_stack.current
--> 630     arg = pack_args(self._type_signature.parameter, args, kwargs, context)
    631     return context.invoke(self, arg)
    632 

~\Anaconda3\envs\tff\lib\site-packages\tensorflow_federated\python\core\impl\function_utils.py in pack_args(parameter_type, args, kwargs, context)
    385       else:
    386         arg = pack_args_into_anonymous_tuple(args, kwargs, parameter_type,
--> 387                                              context)
    388       return context.ingest(arg, parameter_type)
    389 

~\Anaconda3\envs\tff\lib\site-packages\tensorflow_federated\python\core\impl\function_utils.py in pack_args_into_anonymous_tuple(args, kwargs, type_spec, context)
    307           else:
    308             arg_value = args[index]
--> 309             result_elements.append((name, context.ingest(arg_value, elem_type)))
    310             positions_used.add(index)
    311         elif name is not None and name in kwargs:

~\Anaconda3\envs\tff\lib\site-packages\tensorflow_federated\python\core\impl\reference_executor.py in ingest(self, arg, type_spec)
    666       return fn
    667 
--> 668     return to_representation_for_type(arg, type_spec, _handle_callable)
    669 
    670   def invoke(self, fn, arg):

~\Anaconda3\envs\tff\lib\site-packages\tensorflow_federated\python\core\impl\reference_executor.py in to_representation_for_type(value, type_spec, callable_handler)
    240       return [
    241           to_representation_for_type(v, type_spec.member, callable_handler)
--> 242           for v in value
    243       ]
    244   else:

~\Anaconda3\envs\tff\lib\site-packages\tensorflow_federated\python\core\impl\reference_executor.py in <listcomp>(.0)
    240       return [
    241           to_representation_for_type(v, type_spec.member, callable_handler)
--> 242           for v in value
    243       ]
    244   else:

~\Anaconda3\envs\tff\lib\site-packages\tensorflow_federated\python\core\impl\reference_executor.py in to_representation_for_type(value, type_spec, callable_handler)
    199         return [
    200             to_representation_for_type(v, type_spec.element, callable_handler)
--> 201             for v in value
    202         ]
    203       else:

~\Anaconda3\envs\tff\lib\site-packages\tensorflow_federated\python\core\impl\reference_executor.py in <listcomp>(.0)
    199         return [
    200             to_representation_for_type(v, type_spec.element, callable_handler)
--> 201             for v in value
    202         ]
    203       else:

~\Anaconda3\envs\tff\lib\site-packages\tensorflow_federated\python\core\impl\reference_executor.py in to_representation_for_type(value, type_spec, callable_handler)
    191                 value_elem_name, type_elem_name, index, value, type_spec))
    192       converted_value_elem = to_representation_for_type(value_elem, type_elem,
--> 193                                                         callable_handler)
    194       result_elements.append((type_elem_name, converted_value_elem))
    195     return anonymous_tuple.AnonymousTuple(result_elements)

~\Anaconda3\envs\tff\lib\site-packages\tensorflow_federated\python\core\impl\reference_executor.py in to_representation_for_type(value, type_spec, callable_handler)
    163       raise TypeError(
    164           'The tensor type {} of the value representation does not match '
--> 165           'the type spec {}.'.format(str(inferred_type_spec), str(type_spec)))
    166     return value
    167   elif isinstance(type_spec, computation_types.NamedTupleType):

TypeError: The tensor type int64[8,100] of the value representation does not match the type spec int32[?,100].

Similarly, the notebook for image classification doesn't work as well.

Why the evaluation on test using the sample_clients from training in the EMNIST tutorial?

I went through the EMNIST tutorial https://www.tensorflow.org/federated/tutorials/federated_learning_for_image_classification
, but found the problem in the evaluation section:

federated_test_data = make_federated_data(emnist_test, sample_clients)
len(federated_test_data), federated_test_data[0]

The federated_test_data is generated from sample_clients, while the sample_clients comes from the training set

#@test {"output": "ignore"}
NUM_CLIENTS = 3
sample_clients = emnist_train.client_ids[0:NUM_CLIENTS]
federated_train_data = make_federated_data(emnist_train, sample_clients)
len(federated_train_data), federated_train_data[0]

Why not take it as

sample_clients_test = emnist_test.client_ids[0:NUM_CLIENTS]
federated_test_data = make_federated_data(emnist_test, sample_clients_test)
evaluation(state.model, federated_test_data)

Is that an error or can someone explain it?

Tensor is not an element of this graph

I've tried to reproduce a tutorial "Federated Learning for Image Classification" in Colab [1] and encountered a ValueError during execution

iterative_process = tff.learning.build_federated_averaging_process(model_fn)

The error is following:

 ---------------------------------------------------------------------------
 ValueError                                Traceback (most recent call last)
 /usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py in _run(self, handle, fetches, feed_dict, options, run_metadata)
    1091             subfeed_t = self.graph.as_graph_element(
 -> 1092                 subfeed, allow_tensor=True, allow_operation=False)
    1093           except Exception as e:

 /usr/local/lib/python3.6/dist-packages/tensorflow/python/framework/ops.py in as_graph_element(self, obj, allow_tensor, allow_operation)
    3477     with self._lock:
 -> 3478       return self._as_graph_element_locked(obj, allow_tensor, allow_operation)
    3479 

 /usr/local/lib/python3.6/dist-packages/tensorflow/python/framework/ops.py in _as_graph_element_locked(self, obj, allow_tensor, allow_operation)
    3556       if obj.graph is not self:
 -> 3557         raise ValueError("Tensor %s is not an element of this graph." % obj)
    3558       return obj

 ValueError: Tensor Tensor("Placeholder:0", shape=(), dtype=float32) is not an element of this graph.

How it can be solved?

[1] https://colab.research.google.com/github/tensorflow/federated/blob/master/docs/tutorials/federated_learning_for_image_classification.ipynb

Can TFF be used for training on mobile phone?

the model we can get now can be used on mobile phone for federated_learning?

Follow up on #258 TFF with BatchNormalization

Hello
I followed the discussion on #258 about keras models with batch_normalization, this is the relevant part of the code:

for round_num in range(2, 70): 
    FLstate, FLoutputs = trainer_Itr_Process.next(FLstate, federated_train_data)   
    FLlosses_arr.append(FLoutputs.loss)
    tff_weights= tff.learning.keras_weights_from_tff_weights(FLstate.model)
    tff_weights.assign_weights_to(tff_weights, Local_model_Fed)

I appreciate the help with the following error:

Traceback (most recent call last):
  File "C:\Users\ezalaab\.p2\pool\plugins\org.python.pydev.core_7.1.0.201902031515\pysrc\pydevd.py", line 2225, in <module>
    main()
  File "C:\Users\ezalaab\.p2\pool\plugins\org.python.pydev.core_7.1.0.201902031515\pysrc\pydevd.py", line 2218, in main
    globals = debugger.run(setup['file'], None, None, is_module)
  File "C:\Users\ezalaab\.p2\pool\plugins\org.python.pydev.core_7.1.0.201902031515\pysrc\pydevd.py", line 1560, in run
    return self._exec(is_module, entry_point_fn, module_name, file, globals, locals)
  File "C:\Users\ezalaab\.p2\pool\plugins\org.python.pydev.core_7.1.0.201902031515\pysrc\pydevd.py", line 1567, in _exec
    pydev_imports.execfile(file, globals, locals)  # execute the script
  File "C:\Users\ezalaab\.p2\pool\plugins\org.python.pydev.core_7.1.0.201902031515\pysrc\_pydev_imps\_pydev_execfile.py", line 25, in execfile
    exec(compile(contents+"\n", file, 'exec'), glob, loc)
  File "C:\Users\ezalaab\Documents\eclipse-workspace\MANA-FederatedLearning\location-based-federated-learning\Test\FederatedLearningTFv3.py", line 299, in <module>
    tff_weights.assign_weights_to(tff_weights, Local_model_Fed)
AttributeError: 'list' object has no attribute 'assign_weights_to

Error tf.keras.losses

Hello, i am trying with the tutorial of image classification when I met the error which said "keras.losses' has no attribute 'SparseCategoricalCrossentropy'". How to fix it? Is that a problem of version of my tensorflow?
Another question is that how many kinds of loss functions does tff support?
Thank you in advance!

Results cannot improve by rounding (.next): Federated TF

Hello

I'm trying to compare federated learning TF with keras fitting, as we see below. However, the results of TFF does not improve by rounding. Also, when I set weight a local model based on the TFF model, I get worse results than normally training the model on keras. The Loss results are mentioned after the code.

Thanks for the help.

Regards

Code:

tf.compat.v1.enable_v2_behavior()

TobeRemoved_Array = ['feature1','feature2','feature3','feature4','feature5','feature6','feature7', 'is_training']

train_perc = 0.8
Norm_Input = True
Norm_Output = False
Input_str = ['feature1', 'feature2']
if Norm_Output:
Output_str = ['feature3']
else:
Output_str = ['feature4']

Final_Tag = 'Tag3' # here just decide which tagging method do you want to use
Num_Clients = 10 # cannot be less than one
Num_Cons_Sample_Client = 5 # cannot be less than one

Load simulation data.

##############################################
dir_name = 'pickle-data/'
file_name = 'logs_april_2019.pickle'
files = os.listdir('pickle-data/')
dataframe = Import_Pickle.Import_v1(dir_name,file_name,False) # choose False to use 2019 data

Just to reduce the processing

ave = dataframe.core.min() + 1000000000
df2 = dataframe[dataframe.core < ave]
df = Import_Pickle.PreProcessing_v2019(df2,Norm_Input)
train_df,test_df,X_traindf,X_testdf,Y_traindf,Y_testdf,XY_traindf,XY_testdf = Import_Pickle.Splitting_Train_Test(df,train_perc,Norm_Output,TobeRemoved_Array)
########## splitting for clients ############
def Tag_per_day(train_df_loc,TagNum):
train_df_loc['log2'] = train_df_loc['log'].apply(lambda x: x.replace("_",""))
tag_Index = train_df_loc.log2.apply(lambda x: x.index("201"))
tag_Index2 = tag_Index.values[1]
tag_date =train_df_loc.log2.apply(lambda x: x[tag_Index2:tag_Index2+8])
train_df_loc.loc[:,'Tag'+str(TagNum)] = pd.Series(tag_date.to_list(),index=train_df.index) # to be fixed
return train_df_loc

Introduce time as input

X_traindf['feature1'] = train_df['feature1']

introduce first tag per day

TagNum=1
train_df = Tag_per_day(train_df,TagNum)
#examples on groupby
Unq_tag1_grps = list(train_df.groupby(train_df.Tag1).groups.keys())
train_df.groupby(train_df.Tag1).first()
train_df.groupby(train_df.Tag1)['feature1'].count()
X_traindf['Tag'+str(TagNum)] = train_df['Tag'+str(TagNum)]
#############################

introduce epoch as tag

#############################
TagNum=2
train_df['Tag'+str(TagNum)] = train_df.epoch
X_traindf['Tag'+str(TagNum)] = train_df['Tag'+str(TagNum)]
#############################

introduce core as tag

#############################
TagNum=3
train_df['Tag'+str(TagNum)] = train_df.core
X_traindf['Tag'+str(TagNum)] = train_df['Tag'+str(TagNum)]
#############################

introduce day as tag per client

#############################
TagNum = 4
RepNum = np.ceil(train_df.shape[0]/(Num_Cons_Sample_Client*Num_Clients))
Part_Tag_Array=[]
for i in np.arange(Num_Clients):
Part_Tag_Tmp = list(map(lambda _: i+1,range(Num_Cons_Sample_Client)))
Part_Tag_Array.extend(Part_Tag_Tmp)

Full_Tag_Array2 = Part_Tag_Array * int(RepNum)
extra_tags = np.abs(len(Full_Tag_Array2) - train_df.shape[0])
Full_Tag_Array = Full_Tag_Array2[:-extra_tags]

train_df.loc[:,'Tag'+str(TagNum)] = pd.Series(Full_Tag_Array,index=train_df.index)
X_traindf.loc[:,'Tag'+str(TagNum)] = train_df['Tag'+str(TagNum)]
#############################

END day as tag per client

#############################
######### Introduce gpsTime and Tag to the input
Input_str.extend(['feature1',Final_Tag])

Adding StandardSalarization:

scaler = StandardScaler()
removed_column = Input_str.pop()
X_train_ScaledTmp = scaler.fit_transform(X_traindf[Input_str],Y_traindf[Output_str])

Adding Int tag per client without scalarization

X_train_Scaled = np.c_[X_train_ScaledTmp, train_df[removed_column].values.reshape(train_df.shape[0],1)]

All In/Out data Numpy

Act_Inputs_Int_Tag = X_train_Scaled
Act_Outputs_Int = Y_traindf[Output_str].values

Remove Tags

Act_Inputs_Int = np.delete(Act_Inputs_Int_Tag,-1,axis=1)

prepare In/Out per Client

All_Act_Inputs_Int_Tag = [Act_Inputs_Int_Tag[np.where(Act_Inputs_Int_Tag[:,-1]== x)] for x in np.arange(1,Num_Clients+1)]
All_Act_Outputs_Int = [Act_Outputs_Int[np.where(Act_Inputs_Int_Tag[:,-1]== x)] for x in np.arange(1,Num_Clients+1)]

Remove Tags

All_Act_Inputs_Int = [np.delete(All_Act_Inputs_Int_Tag[x],-1,axis=1) for x in np.arange(0,Num_Clients) ]

a need conversion to float32

Act_Inputs = np.float32(Act_Inputs_Int)
Act_Outputs = np.float32(Act_Outputs_Int)

convert dataset to client based dataset

All_Act_Inputs = [np.float32(All_Act_Inputs_Int[x]) for x in np.arange(0,Num_Clients)]
All_Act_Outputs = [np.float32(All_Act_Outputs_Int[x]) for x in np.arange(0,Num_Clients)]

convert to OrderedDict

new_batch = collections.OrderedDict([('In', Act_Inputs),('Out', Act_Outputs)])
All_new_batch = [collections.OrderedDict([('In', All_Act_Inputs[x]),('Out', All_Act_Outputs[x])]) for x in np.arange(0,Num_Clients)]

Convert to tensor

dataset_input = tf.data.Dataset.from_tensor_slices(new_batch)#,,maxval=100, dtype=tf.float32)

All_new_batch has different item per In / Out

All_dataset_input = [tf.data.Dataset.from_tensor_slices(All_new_batch[x]) for x in np.arange(0,Num_Clients)]

Select among the datasets

Used_dataset= dataset_input
All_Used_dataset= All_dataset_input

#with eager_mode():
learning_rate = 1
Val_Train_Split = 0.8
SNN_epoch = 50
SNN_batch_size = 1100
shuffle_buffer = 200

def preprocess(new_dataset):
#return Used_dataset.repeat(2).batch(2)
def map_fn(elem):
return collections.OrderedDict([('x', tf.reshape(elem['In'], [-1])),('y', tf.reshape(elem['Out'],[1]))])

DS2= new_dataset.map(map_fn)
return DS2.repeat(SNN_epoch).batch(SNN_batch_size)

train_data = [preprocess(Used_dataset)]

#######changes###############33
def make_federated_data(client_data, client_ids):
return [preprocess(client_data[x]) for x in client_ids]

federated_train_data = make_federated_data(All_Used_dataset, np.arange(0,Num_Clients))

sample_batch = tf.contrib.framework.nest.map_structure(lambda x: x.numpy(), next(iter(train_data[0])))

########## END Changes ############

def create_SK_model():
modelF = tf.keras.Sequential([tf.keras.layers.Flatten(input_shape=(Act_Inputs.shape[1],)),
tf.keras.layers.Dense(10, activation=tf.nn.relu, kernel_initializer='zeros'),
tf.keras.layers.Dense(100, activation=tf.nn.relu, kernel_initializer='zeros'),
tf.keras.layers.Dropout(0.5),
tf.keras.layers.Dense(100, activation=tf.nn.relu, kernel_initializer='zeros'),
tf.keras.layers.Dropout(0.5),
tf.keras.layers.Dense(1, activation=tf.nn.relu, kernel_initializer='zeros'),
])
return modelF

def loss_fn(y_true, y_pred):
return tf.reduce_mean(tf.keras.losses.MSE(y_true, y_pred))

def model_fn():
return tff.learning.from_keras_model(create_SK_model(),
sample_batch, loss=loss_fn,
optimizer=gradient_descent.SGD(0.1))

YTrain = Act_Outputs #np.random.rand(50,1)
XTrain = Act_Inputs #np.random.rand(50,100)

locally compile the model

Local_model = create_SK_model()
Local_model.compile(loss=loss_fn,optimizer=gradient_descent.SGD(learning_rate))

training/fitting with TF federated learning

trainer_Itr_Process = tff.learning.build_federated_averaging_process(model_fn,server_optimizer_fn=(lambda : gradient_descent.SGD(learning_rate=1.0)),client_weight_fn=None)
FLstate = trainer_Itr_Process.initialize()
FLlosses = []

Track loss of different ...... of federated iteration

for round_num in range(2, 5):
"""
The second of the pair of federated computations, next, represents a single round of Federated Averaging, which consists of pushing the server state (including the model parameters) to the clients, on-device training on their local data, collecting and averaging model updates, and producing a new updated model at the server.
"""
FLstate, FLoutputs = trainer_Itr_Process.next(FLstate, federated_train_data)
print('round {:2d}, metrics={}'.format(round_num, FLoutputs.loss))
# Track the loss.
FLlosses.append(FLoutputs.loss)

fitting without federated learning

trained_local_Model = Local_model.fit(XTrain,YTrain, validation_split=Val_Train_Split, epochs=SNN_epoch, batch_size=SNN_batch_size) #tbuc

Loss of local model

local_Loss = trained_local_Model.history['loss'] # tbuc
print("Local Model Loss: "+str(local_Loss))

Copy local model for comparison purposes

Local_model_Fed = Local_model

Setting federated weights on copied Object of local model

Local_model_Fed.set_weights(tff.learning.keras_weights_from_tff_weights(FLstate.model))

Evaluate loss of the copied federated weights on local model

Fed_predicted = Local_model_Fed.predict(XTrain)
Fed_eval = Local_model_Fed.evaluate(XTrain,YTrain)

print("Local Model with Federated Weights Loss: "+str(Fed_eval ))
print("New: " + str(Local_model_Fed.loss))
print('End')

Output:

round 2, metrics=6838.99658203125
round 3, metrics=6838.99658203125
round 4, metrics=6838.99658203125
round 5, metrics=6838.99658203125
round 6, metrics=6838.99658203125
Train on 733 samples, validate on 2936 samples
Epoch 1/50

733/733 [==============================] - 0s 14us/sample - loss: 6449.8022 - val_loss: 6936.1622
Epoch 4/50
.........................................................
733/733 [==============================] - 0s 18us/sample - loss: 6449.8022 - val_loss: 6936.1622

Local Model Loss: [6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375, 6449.80224609375]

32/3669 [..............................] - ETA: 0s - loss: 10104.2188
1632/3669 [============>.................] - ETA: 0s - loss: 6897.5380
3232/3669 [=========================>....] - ETA: 0s - loss: 6860.1061
3669/3669 [==============================] - 0s 31us/sample - loss: 6838.9962
Local Model with Federated Weights Loss: 6838.996183714057

AttributeError: module 'tensorflow._api.v1.data.experimental' has no attribute 'NestedStructure'

Hello,
I was able to run my code just 2 days ago on colab, but now I can't because of this error AttributeError: module 'tensorflow._api.v1.data.experimental' has no attribute 'NestedStructure' . The error is related to tff.learning.build_federated_averaging_process(model_fn).
What is the source of this problem ?
Thank you

About the server

Hello, I would like to ask, there is no data training on the server side, but the server will merge the models of each client and update based on FedAvg algorithm, then the model I got is the final server model? Moreover, how do I get the client model?

should I use swift for tensorflow when deploying real devices?

I guess current tff only support simulation, but I wonder what is the plan for real deployment on iphone. should I use swift for tensorflow for federated learning on real device?

Federated in Tensorflow.js

Will this api be exposed in Tensorflow.js?
So that you can join in the federation from a browser tab.

No output from tff.federated_computation(), image classification example

When i execute image classification example in the link below:
https://github.com/tensorflow/federated/blob/master/docs/tutorials/federated_learning_for_image_classification.ipynb
Following the installation steps provided.
I am not getting ourput of 'Hello, World!'

System: Ubuntu 18.04
Output:

Please help to know the reason.

Error in pip installation in venv: No matching distribution found

When following the install from package instructions, I receive an error when attempting pip installation: Could not find a version that satisfies the requirement tensorflow_federated (from versions: ) No matching distribution found for tensorflow_federated

Steps to reproduce:

$ /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
$ export PATH="/usr/local/bin:/usr/local/sbin:$PATH"
$ brew update
$ brew install python  # Python 3
$ sudo pip3 install --upgrade virtualenv  # system-wide install
$ virtualenv --python python3 "venv"
$ source "venv/bin/activate"
(venv) $ pip install --upgrade pip
(venv) $ pip install tensorflow_federated
Collecting tensorflow_federated
*Could not find a version that satisfies the requirement tensorflow_federated (from versions: )
No matching distribution found for tensorflow_federated*

System info:

pip 10.0.1
Homebrew 2.0.1
Python 3.6.7
macOS High Sierra 10.13.6

Using GPU produces error after upgrading to 0.4.0

I updated TFF to 0.4.0 yesterday and found that the image classification tutorial cannot be run correctly now (which worked in previous TFF versions). After executing

#@test {"timeout": 600, "output": "ignore"}
state, metrics = iterative_process.next(state, federated_train_data)
print('round 1, metrics={}'.format(metrics))

The following error message occurs. I believe this problem is also partly mentioned here. Plus, I am interested in knowing of optimizing GPU usage for TFF possibly by looping on the clients in parallel (as the previous closed issue). Or is there any advice on speeding up the federated training? Now it takes really long time when having a large neural network. Thank you!

InvalidArgumentError Traceback (most recent call last)
~/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tensorflow/python/client/session.py in _do_call(self, fn, *args)
1333 try:
-> 1334 return fn(*args)
1335 except errors.OpError as e:

~/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tensorflow/python/client/session.py in _run_fn(feed_dict, fetch_list, target_list, options, run_metadata)
1318 return self._call_tf_sessionrun(
-> 1319 options, feed_dict, fetch_list, target_list, run_metadata)
1320

~/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tensorflow/python/client/session.py in _call_tf_sessionrun(self, options, feed_dict, fetch_list, target_list, run_metadata)
1406 self._session, options, feed_dict, fetch_list, target_list,
-> 1407 run_metadata)
1408

InvalidArgumentError: Could not colocate node with its resource and reference inputs; devices /job:localhost/replica:0/task:0/device:CPU:0 and /job:localhost/replica:0/task:0/device:GPU:0 are not compatible.
[[{{node ReduceDataset}}]]
[[{{node subcomputation/StatefulPartitionedCall_1}}]]
[[{{node subcomputation/StatefulPartitionedCall_1}}]]

During handling of the above exception, another exception occurred:

InvalidArgumentError Traceback (most recent call last)
in ()
1 #@test {"timeout": 600, "output": "ignore"}
----> 2 state, metrics = iterative_process.next(state, federated_train_data)
3 print('round 1, metrics={}'.format(metrics))

~/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tensorflow_federated/python/core/impl/function_utils.py in call(self, *args, **kwargs)
598 context = self._context_stack.current
599 arg = pack_args(self._type_signature.parameter, args, kwargs, context)
--> 600 return context.invoke(self, arg)
601
602

~/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tensorflow_federated/python/core/impl/reference_executor.py in invoke(self, fn, arg)
698 else:
699 computed_arg = None
--> 700 result = computed_comp.value(computed_arg)
701 py_typecheck.check_type(result, ComputedValue)
702 type_utils.check_assignable_from(comp.type_signature.result,

~/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tensorflow_federated/python/core/impl/reference_executor.py in (x)
841 return ComputationContext(context, {comp.parameter_name: arg})
842
--> 843 return ComputedValue(lambda x: self._compute(comp.result, _wrap(x)),
844 comp.type_signature)
845

~/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tensorflow_federated/python/core/impl/reference_executor.py in _compute(self, comp, context)
744 return self._compute_call(comp, context)
745 elif isinstance(comp, computation_building_blocks.Tuple):
--> 746 return self._compute_tuple(comp, context)
747 elif isinstance(comp, computation_building_blocks.Reference):
748 return self._compute_reference(comp, context)

~/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tensorflow_federated/python/core/impl/reference_executor.py in _compute_tuple(self, comp, context)
800 result_type_elements = []
801 for k, v in anonymous_tuple.to_elements(comp):
--> 802 computed_v = self._compute(v, context)
803 type_utils.check_assignable_from(v.type_signature,
804 computed_v.type_signature)

~/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tensorflow_federated/python/core/impl/reference_executor.py in _compute(self, comp, context)
742 return self._compute_compiled(comp, context)
743 elif isinstance(comp, computation_building_blocks.Call):
--> 744 return self._compute_call(comp, context)
745 elif isinstance(comp, computation_building_blocks.Tuple):
746 return self._compute_tuple(comp, context)

~/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tensorflow_federated/python/core/impl/reference_executor.py in _compute_call(self, comp, context)
782 computation_types.FunctionType)
783 if comp.argument is not None:
--> 784 computed_arg = self._compute(comp.argument, context)
785 type_utils.check_assignable_from(computed_fn.type_signature.parameter,
786 computed_arg.type_signature)