目录

• I. 前言
• II. 数据介绍
• III. 联邦学习
  *
• 1. 整体框架
• 2. 服务器端
• 3. 客户端
• IV. Tensorflow Federated
  *
• 1. 数据处理
• 2. 构造TFF的Keras模型
• 3. 训练
• 4. 测试
• 5. 实验结果及分析
• V. 一些思考
• VI. 源码及数据

I. 前言

关于联邦学习，前面已经有几篇文章做了一些阐述：

1. 联邦学习原始论文解读
2. IEEE ICIP 2019 | 更快更好的联邦学习：一种特征融合方法
   
3. 联邦学习基本算法FedAvg的代码实现
4. KBS 2021 | 联邦学习综述
5. WorldS4 2020 | 联邦学习的个性化技术综述

谷歌作为联邦学习的提出者，在其深度学习框架TensorFlow的基础上开发出了一套联邦学习的框架Tensorflow Federated（后文简称TFF）。TFF是一个开源框架，用于机器学习和其他分散数据计算，其开发旨在促进联邦学习的研究与试验。

TFF的接口分为两层：

1. Federated Learning (FL) API：该层提供了一组高级接口，允许开发人员将包含的联邦训练和评估实现应用到他们现有的TensorFlow模型中。
2. Federated Core (FC) API：该系统的核心是一组较低级别的接口，用于通过在强类型函数式编程环境中将TensorFlow与分布式通信运算符相结合来简洁地表达联邦算法。这一层也是我们构建联邦学习的基础。

之前我一直用的是PyTorch，之前的一篇博客联邦学习基本算法FedAvg的代码实现也是基于numpy来实现的，因此很少接触TensorFlow。

不过没办法，自己造轮子的效果不是很好，PyTorch也没有对联邦学习进行封装，那就只有学习TensorFlow以及Tensorflow Federated了。

有关TensorFlow和Tensorflow Federated的安装可以参考我的另一篇博客：安装tensorflow-gpu和tensorflow_federated。

II. 数据介绍

在联合学习中有多个客户端，每个客户端都有自己不想共享的数据集。

本文选用的数据集为 中国北方某城市10个区/县从2016年到2019年三年的真实用电负荷数据，采集时间间隔为1小时，即每一天都有24个负荷值。

我们假设这10个地区的电力部门不愿意共享自己的数据，但是他们又想得到一个由所有数据统一训练得到的全局模型。

这里我们用某一时刻前24个时刻的负荷值以及该时刻的相关气象数据（如温度、湿度、压强等）来预测该时刻的负荷值。各个地区应该就如何制定特征集达成一致意见，本文使用的各个地区上的数据的特征是一致的，可以直接使用。

不过有一点需要注意： 客户端参与联邦学习的主要动机是获得更好的模型。客户端如果没有足够的私人数据来开发准确的本地模型，就可以从联邦学习的模型中获益。然而，对于有足够私人数据来训练准确的本地模型的客户来说，参与联邦学习是否有好处是有争议的。这里每个客户端都拥有了足够多的本地数据，因此仅仅利用本地数据训练出的模型应该比全局模型表现出更好的性能，实验结果也证实了这一点。

III. 联邦学习

1. 整体框架

原始论文中提出的FedAvg的框架为：

本文中需要利用各个客户端的模型参数来对服务器端的模型参数进行更新，这里采用TensorFlow的keras模块来搭建了一个简单的神经网络：

model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(20, tf.nn.sigmoid, input_shape=(30,),
                          kernel_initializer='zeros'),
    tf.keras.layers.Dense(20, tf.nn.sigmoid),
    tf.keras.layers.Dense(20, tf.nn.sigmoid),
    tf.keras.layers.Dense(1, tf.sigmoid)
])

2. 服务器端

服务器端执行以下步骤：

1. 初始化参数
2. 对第t轮训练来说：首先计算出m = m a x ( C ⋅ K , 1 ) m=max(C \cdot K, 1)m =m a x (C ⋅K ,1 )，然后随机选择m个客户端，对这m个客户端做如下操作（所有客户端并行执行）：更新本地的w t k w_t^{k}w t k ​得到w t + 1 k w_{t+1}^{k}w t +1 k ​。所有客户端更新结束后，将w t + 1 k w_{t+1}^{k}w t +1 k ​传到服务器，服务器整合所有w t + 1 k w_{t+1}^{k}w t +1 k ​得到最新的全局参数w t + 1 w_{t+1}w t +1 ​。
3. 服务器将最新的w t + 1 w_{t+1}w t +1 ​分发给所有客户端，然后进行下一轮的更新。

简单地说，就是在每一轮通信中只选择一些客户端，这些客户端用本地数据更新参数，然后传递给服务器，服务器将所有客户端的参数聚合成自己的参数，然后再将汇总后的参数分发给所有客户端，然后进行下一轮更新。

3. 客户端

客户端无话可说，只能使用本地数据更新神经网络模型的参数。

IV. Tensorflow Federated

1. 数据处理

代码：

def client_data(n, B, train_flag):
    print('处理数据:')
    data = load_data(clients[n])
    if train_flag:
        data = data[0:int(len(data) * 0.9)]
    else:
        data = data[int(len(data) * 0.9):len(data)]

    load = data[data.columns[1]].values.tolist()

    data = data.values.tolist()
    X, Y = [], []
    for i in range(len(data) - 30):
        train_seq = []

        for j in range(i, i + 24):
            train_seq.append(load[j])

        for c in range(2, 8):
            train_seq.append(data[i + 24][c])
        Y.append(load[i + 24])
        X.append(train_seq)

    X = tf.reshape(X, [len(X), -1])
    Y = tf.reshape(Y, [len(Y), -1])
    X = tf.data.Dataset.from_tensor_slices(X)
    Y = tf.data.Dataset.from_tensor_slices(Y)

    seq = tf.data.Dataset.zip((X, Y))
    seq = seq.batch(B, drop_remainder=True).shuffle(100).prefetch(B)

    return seq

对于函数client_data(n, B, train_flag)，如果train_flag=True，返回客户端n的batch_size=B的训练集，否则返回测试集。

任意输出其中一条数据：

print(list(seq.as_numpy_iterator())[0])

结果：

(array([[0.4195624 , 0.43211627, 0.48750123, 0.46142522, 0.50673616,
        0.49603754, 0.46745548, 0.4261831 , 0.4905846 , 0.49231917,
        0.47030267, 0.5219719 , 0.52490044, 0.4579194 , 0.43583727,
        0.41776225, 0.34858742, 0.33259332, 0.40729982, 0.3909672 ,
        0.393119  , 0.36626622, 0.37780192, 0.35956943, 0.        ,
        1.        , 0.26086956, 0.6666667 , 0.41860464, 0.34146342],
       [0.43211627, 0.48750123, 0.46142522, 0.50673616, 0.49603754,
        0.46745548, 0.4261831 , 0.4905846 , 0.49231917, 0.47030267,
        0.5219719 , 0.52490044, 0.4579194 , 0.43583727, 0.41776225,
        0.34858742, 0.33259332, 0.40729982, 0.3909672 , 0.393119  ,
        0.36626622, 0.37780192, 0.35956943, 0.42298427, 0.        ,
        1.        , 0.3043478 , 0.6666667 , 0.41860464, 0.34146342],
       [0.48750123, 0.46142522, 0.50673616, 0.49603754, 0.46745548,
        0.4261831 , 0.4905846 , 0.49231917, 0.47030267, 0.5219719 ,
        0.52490044, 0.4579194 , 0.43583727, 0.41776225, 0.34858742,
        0.33259332, 0.40729982, 0.3909672 , 0.393119  , 0.36626622,
        0.37780192, 0.35956943, 0.42298427, 0.39648312, 0.        ,
        1.        , 0.3478261 , 0.6666667 , 0.41860464, 0.34146342],
       [0.46142522, 0.50673616, 0.49603754, 0.46745548, 0.4261831 ,
        0.4905846 , 0.49231917, 0.47030267, 0.5219719 , 0.52490044,
        0.4579194 , 0.43583727, 0.41776225, 0.34858742, 0.33259332,
        0.40729982, 0.3909672 , 0.393119  , 0.36626622, 0.37780192,
        0.35956943, 0.42298427, 0.39648312, 0.4274243 , 0.        ,
        1.        , 0.39130434, 0.6666667 , 0.41860464, 0.34146342],
       [0.50673616, 0.49603754, 0.46745548, 0.4261831 , 0.4905846 ,
        0.49231917, 0.47030267, 0.5219719 , 0.52490044, 0.4579194 ,
        0.43583727, 0.41776225, 0.34858742, 0.33259332, 0.40729982,
        0.3909672 , 0.393119  , 0.36626622, 0.37780192, 0.35956943,
        0.42298427, 0.39648312, 0.4274243 , 0.44137946, 0.        ,
        1.        , 0.4347826 , 0.6666667 , 0.41860464, 0.34146342]],
      dtype=float32), array([[0.42298427],
       [0.39648312],
       [0.4274243 ],
       [0.44137946],
       [0.44090188]], dtype=float32))

这里batch_size=5。

2. 构造TFF的Keras模型

def model_fn():
    model = tf.keras.models.Sequential([
        tf.keras.layers.Dense(20, tf.nn.sigmoid, input_shape=(30,),
                              kernel_initializer='zeros'),
        tf.keras.layers.Dense(20, tf.nn.sigmoid),
        tf.keras.layers.Dense(20, tf.nn.sigmoid),
        tf.keras.layers.Dense(1, tf.sigmoid)
    ])
    return tff.learning.from_keras_model(
        model,
        input_spec=train_data[0].element_spec,
        loss=tf.keras.losses.MeanSquaredError(),
        metrics=[tf.keras.metrics.MeanAbsolutePercentageError()])

其中model是一个简单的Keras模型，model_fn()最终返回的是一个tff.learning.Model，该模型将用于联邦学习。来看一下官方API：

tff.learning.from_keras_model(
    keras_model: tf.keras.Model,
    loss: Loss,
    input_spec,
    loss_weights: Optional[List[float]] = None,
    metrics: Optional[List[tf.keras.metrics.Metric]] = None
) -> tff.learning.Model

1. keras_model：为联邦学习封装的Keras模型，该模型不能compile。
2. loss：损失函数。如果只提供一个损失函数，则所有模型都使用该损失函数；如果提供一个损失函数列表，则与各个客户端模型相互对应。这里选择MSE。
3. input_sec：指定模型的输入数据类型。input_spec必须是两个元素的复合结构，即x和y。如果作为列表提供，则必须按 [x, y]的顺序，如果作为字典提供，则键必须明确命名为"x"和"y"。本文是按照列表进行提供的。
4. loss_weights：可选项。如果loss为一个列表，那么就可以为每一个客户端的loss指定一个权重，最后求加权和。
5. metrics：可选项。这里选择了MAPE。

3. 训练

def train():

    trainer = tff.learning.build_federated_averaging_process(
        model_fn,
        client_optimizer_fn=lambda: tf.keras.optimizers.Adam(0.08),

    )
    state = trainer.initialize()
    for _ in range(20):
        state, metrics = trainer.next(state, train_data)
        print('loss:', metrics['train']['loss'])

首先需要定义一个tff.templates.IterativeProcess对象：

trainer = tff.learning.build_federated_averaging_process(
    model_fn,
    client_optimizer_fn=lambda: tf.keras.optimizers.Adam(0.08)
)

看一下官方API：

tff.learning.build_federated_averaging_process(
    model_fn: Callable[[], tff.learning.Model],
    client_optimizer_fn: Callable[[], tf.keras.optimizers.Optimizer],
    server_optimizer_fn: Callable[[], tf.keras.optimizers.Optimizer] = DEFAULT_SERVER_OPTIMIZER_FN,
    *,
    client_weighting: Optional[tff.learning.ClientWeighting] = None,
    broadcast_process: Optional[tff.templates.MeasuredProcess] = None,
    aggregation_process: Optional[tff.templates.MeasuredProcess] = None,
    model_update_aggregation_factory: Optional[tff.aggregators.WeightedAggregationFactory] = None,
    use_experimental_simulation_loop: bool = False
) -> tff.templates.IterativeProcess

1. model_fn：前面构造的tff.learning.Model对象。
2. client_optimizer_fn：客户端的优化器。这里为Adam(lr=0.08)。
3. server_optimizer_fn：服务器端优化器。默认为SGD(lr=1.0)。
4. client_weighting：梯度聚合方式。默认根据客户端样本数量进行聚合。
5. broadcast_process：一个tff.templates.MeasuredProcess对象，它将服务器上的模型权重广播到客户端，默认使用tff.federated_broadcast进行广播。
6. aggregation_process：一个tff.templates.MeasuredProcess对象，它将客户端的模型权重聚合更新回服务器。
7. model_update_aggregation_factory：用于在服务器上聚合客户端模型更新。
8. use_experimental_simulation_loop：为True时进行高性能GPU模拟。

现在我们定义好了tff.templates.IterativeProcess对象，该对象包含初始化和迭代计算的过程。

state = trainer.initialize()
for r in range(20):
    state, metrics = trainer.next(state, train_data)
    print('round', r + 1,  'loss:', metrics['train']['loss'])

state = trainer.initialize()返回迭代过程对象的初始状态。然后训练20轮：

for r in range(20):
    state, metrics = trainer.next(state, train_data)
    print('round', r + 1,  'loss:', metrics['train']['loss'])

每次调用next方法时，使用广播函数将服务器模型广播到每个客户端。对于每个客户端，通过客户端优化器的tf.keras.optimizers.Optimizer.apply_gradients方法执行一个epoch的本地训练。然后每个客户端计算训练后的客户端模型与初始广播模型之间的差异，再使用一些聚合函数在服务器上聚合这些 模型增量。最后通过使用服务器优化器的tf.keras.optimizers.Optimizer.apply_gradients方法在服务器上应用聚合模型增量。

训练过程：

4. 测试

使用服务器端最终得到的全局模型对每个客户端的本地测试集进行测试：

evaluation = tff.learning.build_federated_evaluation(model_fn)
for i in range(10):
    test_data = [client_data(n, 20, train_flag=False) for n in range(i, i + 1)]

    test_metrics = evaluation(state.model, test_data)
    print(str(test_metrics['mean_absolute_percentage_error'] / len(test_data[0])))

test_metrics = evaluation(state.model, test_data)用于对test_data进行测试，并返回loss和metrics。

5. 实验结果及分析

客户端编号12345678910avg本地模型MAPE / %5.264.816.094.473.813.716.924.712.995.584.74numpy MAPE / %15.1119.0017.8415.3424.7111.0817.4621.558.529.9316.65TFF MAPE / %9.057.056.165.524.877.986.035.477.826.646.66

本地模型MAPE是各个客户端仅利用本地数据进行模型训练后得到的预测表现。numpy MAPE是利用numpy手写联邦学习得到的预测表现（50轮通信），TFF MAPE是利用Tensorflow Federated进行联邦学习（20轮通信）后得到的预测表现。后两种实验方案中的客户端模型是一样的（前者是利用numpy手搭的，后者是利用Keras搭建的）。

可以发现：

1. 由于各个客户端数据量十分充足，本地模型的效果无疑应该是最佳的。
2. TFF仅通信20轮就能十分接近本地模型的效果，并且远好于numpy通信50轮的效果。

V. 一些思考

这就提出了一个问题：既然你的手写模型很差，那么在算法的学习过程中，真的有必要构建自己的车轮吗？

答案是肯定的。在学习的过程中，只有真正理解了模型中的原理，才能知道如何选择合适的模型以及如何修改模型参数。但是，如果您在工作场景中，您可以直接交换数据包，这是基于效率的。然而，即使是标准模型也不能直接在许多业务场景中使用，因此需要对业务进行一些更改。

简单来说， 你可以不重复造轮子，但你得会自己造轮子。

搞算法的人可以简单分成三个类别：

1. 调包很熟练，但对算法的原理不是很了解，这是很多初学者的特征。
2. 调包很熟练，算法原理了解一些，但是自己不能写出来。
3. 能够根据算法原理自己手动写出模型。

努力成为第三种人！

VI. 源码及数据

后面将陆续公开~

Original: https://blog.csdn.net/Cyril_KI/article/details/122901931
Author: Cyril_KI
Title: 利用谷歌的联邦学习框架Tensorflow Federated实现FedAvg（详细介绍）

相关阅读

Title: TensorFlow GPU最完整的安装方法

自己这几天更换电脑，再加上前次旧电脑学习，安装了好几次TensorFlow，每次都遇到了一些问题，经常缺一些文件，在网上下载文件还很慢，走了不少弯路，特将完整的安装方法记录如下，以便后续使用，也供同行参考。

TensorFlow的学习需要有专门的Nvida的GPU显卡的电脑，GPU的显存最好在4G以上，我以前那台电脑只有1G显示只能学习一些非常初级模型，稍微复杂的模型就无法运行。对于没有GPU独显的同学，可以使用百度的AI Studio，上面提供免费的GPU服务器，每天可以免费使用8小时，并且直接安装好百度的PaddlePaddle，系统已经配置好，也可以快速学习人工智能。

一、了解显卡性能及支持的CUDA版本

可以在终端界面，通过nvidia-smi命令查看你的也显卡信息，查看你的电脑是上否有支持CUDA的显卡及相应的型号、显存。

也可以在控制面板中找NVIDIA Control Panel程序，升级Windows 11后发现控制面板中没有NVIDIA的控制面板了，可以在开启程序中通过查找找到。

在NVIDIA控制面板中，通过帮助查单–>系统信息–>组件，找到如下图所示NVCUDA64.dll程序所对应的版本，就是你计算机上CUDA能支持的版本，后续在下载CUDA时一定要与此相匹配，避免兼容性和莫名其妙的问题出现。我的笔记本是新的，显卡是Geforce Rtx 3060，安装的CUDA驱动程序是11.2版本，后续要查找与之对应的CUDA、CUDNN、Tensorflow-GPU版本进行安装，否则会出现不匹配的情况。

; 二、确定TensorFlow与Python版本

在TensorFlow官网的安装指南给出了TensorFlow、Python、CUDA对应的版本，我在前期学习中，由于安装版本问题，走了不少弯路。具体请参阅。
根据前面查询到的CUDA版本11.2，我决定尽可能安装高一些版本的工具，以减少后续组件升级的工作量，因此我确定安装cudnn 8.1，python 3.9，tensorflow 2.6作这台新电脑的研究环境。对于python和tensorflow可以不同项目使用不同的版本，自己后续可以根据项目需要进行调整，但需要尽可能在上图官方已经测试的版本中选择，否则可能出一些兼容性问题。

三、安装CUDA及cuDNN

1、CUDA及cuDNN下载

CUDA(ComputeUnified Device Architecture)，是显卡厂商NVIDIA推出的运算平台。 CUDA是一种由NVIDIA推出的通用并行计算架构，该架构使GPU能够解决复杂的计算问题。

cuDNN是用于深度神经网络的GPU加速库。它强调性能、易用性和低内存开销。NVIDIA cuDNN可以集成到更高级别的机器学习框架中，如谷歌的Tensorflow、加州大学伯克利分校的流行caffe软件。简单的插入式设计可以让开发人员专注于设计和实现神经网络模型，而不是简单调整性能，同时还可以在GPU上实现高性能现代并行计算。

CUDA看作是一个工作台，cuDNN是基于CUDA的深度学习GPU加速库，有了它才能在GPU上完成深度学习的计算。

CUDA下载链接为：https://developer.nvidia.com/cuda-toolkit-archive，找到第一章信息对应的板版本。如下图所示，没有对应的Windows11版本，可以用Windows 10对应的版本可以安装和使用。文件比较大，请使用迅雷等下载工具下载，否则容易下载失败。另下载注意使用Local全部下载，后续查找缺少的Dll文件需要。
cuDNN的下载需要注册一下Nvidia开发帐号才能下载，下载地址为：https://developer.nvidia.com/cudnn。根据网站提示，先用邮箱注册一个开发者帐号，登录后出来下载下载页面，根据第二章确定的cuDNN版本，从归档历史库下载你计算机匹配的cuDNN版本。
2、CUDA安装

安装cuda时，第一次会让设置临时解压目录，第二次会让设置安装目录；临时解压路径，建议默认即可，也可以自定义。安装结束后，临时解压文件夹会自动删除。

安装目录，可以使用默认路径，也可以使用指定路径，关注一下安装路径，后续需要手工将几个程序所在路径加到系统环境变量的path参数中，以便于python程序调用。
CUDA安装过程比较简单，安装完后，将下面几个目录加到系统环境变量的path参数中，以使用python程序调用对应的程序和dll库。

CUDA文件比较大，如果你的计算机硬盘空间足够，建议用自定义选项，全部安装，避免少文件。我的计算机是SSD硬盘，空间不大，采用的是基本安装，在使用时发现少很多文件，刚开始是到网上DLL库上找并下载使用，发现存在文件不全且版本不对应情况，通过修改文件名勉强可以使用，但可能存在兼容性问题。
后面用winrar打开CUDA安装exe文件，可以通过查找功能找到缺少的文件，解压后放在cuda安装目录的bin文件目录下即可。红线文件是CUDA缺少的文件，绿线文件是下一步cuDNN解压拷贝的文件。
3、cuDNN安装

cuDNN是一些动态库文件，用解压缩软件打开，直接解压到前面一条CUDA的安装路径即可，解压后注意确认好文件的路径。此外，注意文件版本，与第2章找到的对应表对应。

四、Python安装

1、Python文件下载

Python下载网站：https://www.python.org/downloads/。Python下载文件不是很好找，容易跳乱，各版的下载导航连接在页面下部，参见下图。
同样，下载文件也是在页面下部，根据自己需要的版本、操作系统找到对应的安装文件，Python安装文件不大，下载很快。
2、Python安装

Python安装时，注意先将下面的增加Python 3.9到path勾选上，避免后续手工添加，另外建议用自定义安装，将python安装到一个简单、短一点的目录，后续经常要用到。
将python安装到C:\python目录， 同时将install for all users选项选中。
python安装成功后，可以在CMD终端下，用python命令进入，检查版本以及是否可用。

五、TensorFlow安装

先在Pycharm中建立一个项目，如果你使用的是其它开发工具，在你对应工具中创建项目。我这儿直接使用的是Virtualenv虚拟环境，使用要简单一些，前面使用过Anaconda，没有感觉到太大优势，问题还不少，这次就直接使用Pycharm的虚拟环境，感觉要简单一些。
注意选择Python解释器，如果你计算机上有多个python要选择与项目兼容的版本。

TensorFlow可以在具体项目中用pip安装，也可以用pycharm的工具安装，注意选择你电脑显卡能支持与兼容的版本，根据第二章，我选择的是2.6版本。
注意安装的是tensorflow-gpu,选择指定的版本，此处选择的是2.6.0，我试过用最新的2.7.0不兼容，无法使用。当前你也可以根据项目前期使用的版本选择对应的TensorFlow版本。此外还要注意对应的python、cuda版本，都要匹配才能正常使用。
TensorFlow安装的包比较多，速度比较慢，建议提前将pip.ini、pycharm的更新仓库都改为国内镜像：（https://pypi.tuna.tsinghua.edu.cn/simple/）。

六、TensorFlow及GPU验证

在项目中创建一个测试文件test.py，以下几行代码即可。

import tensorflow as tf
if tf.test.gpu_device_name():
    print('Default GPU Device: {}'.format(tf.test.gpu_device_name()))
else:
    print("Please install GPU version of TF")

运行test.py如下所述，系统提示运行成功，并显示出GPU的型号，计算能力，我的显卡计算能力为8.6，感觉性能应该还不错，后面根据程序实际的计算性能再发分享报告。

C:\Users\86139\PycharmProjects\test3\venv\Scripts\python.exe C:/Users/86139/PycharmProjects/test3/test.py
2021-11-13 19:50:40.703464: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX AVX2
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.

Default GPU Device: /device:GPU:0
2021-11-13 19:50:42.588444: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1510] Created device /device:GPU:0 with 3495 MB memory:  -> device: 0, name: GeForce RTX 3060 Laptop GPU, pci bus id: 0000:01:00.0, compute capability: 8.6
2021-11-13 19:50:42.589427: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1510] Created device /device:GPU:0 with 3495 MB memory:  -> device: 0, name: GeForce RTX 3060 Laptop GPU, pci bus id: 0000:01:00.0, compute capability: 8.6
Process finished with exit code 0

通过安装上述工具，你可以在自己的电脑上进行人工智能的基础学习和研究。

Original: https://blog.csdn.net/wujize/article/details/121329897
Author: 海盐老伍
Title: TensorFlow GPU最完整的安装方法

Original: https://blog.csdn.net/Cyril_KI/article/details/122901931
Author: Cyril_KI
Title: 利用谷歌的联邦学习框架Tensorflow Federated实现FedAvg（详细介绍）

相关阅读

Title: tensorflow的详细安装（包含jupyter notebook）

安装Anaconda

在官网https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/下载Anaconda
自己用就选Just ME，我这里是对所有用户都可以


完成等待安装

安装完成就打开菜单栏的Anaconda Prompt

进入之后可以输入conda --version来查看下载的版本，我这里下载的是4.8.2版本的

; 安装tensorflow

添加镜像源通道
首先要加一个国内图源频道，一般都是默认的外图连接，下载会很慢。之前使用的是清华大学的图片源，但现在设置了权限，安装后可能会出现问题，可以使用以下命令来删除权限。

conda config

之后再来添加镜像源通道

conda config
conda config
conda config
conda config
conda config

接下来就要开始创建环境了输入

conda create -n tensorflow python=3.7

在正常情况下，不出问题的话是会显示以下，他告诉你启动tensorflow用activate tensorflow，退出用deactivate tensorflow，接下来我们就要进入tensorflow了

但是有的时候会报错的可能性我自己遇到的统计了一下

WARNING: A newer version of conda exists.

=
current version: 4.8.2
latest version: 4.12.0

也许你之前下载的时候发现了一个错误，然后当你再次下载时，你会继续报告它。原因是您之前下载的内容已断开连接，尚未清理。如果你再下载一次，你不知道到哪里去下载。

报错如下所示：

conda clean all

这时候就会发现removing删除之前已经下载的文件包,之后再来下载就可以了

激活tensorflow

输入activate tensorflow,从（base）的前缀变成(tensorflow)的就代表激活成功

安装tensorflow
进入tensorflow之后，输入命令下载tensorflow,这里可以指定tensorflow的版本（tensorflow==2.0.0）,但是有的时候在库里寻找固定版本时间比较长，所以我建议不固定版本，让他自己匹配合适的版本

pip install tensorflow

这样就代表下载完成了，如果不放心，可以使用conda info --envs来查看一下，看看自己是否下载成功，显示tensorflow就表示成功了

conda info

安装jupyter notebook

接下来就简单了，直接利用install安装，选择y,等待安装即可

; 输入jupyter notebook自动跳转到浏览器

在tensorflow里输入jupyter notebook就会自动跳转到浏览器

这个时候很多人都不知道在哪里打开命令执行页面，在右上角有一个New，选择我们下载好的python3.7版本，就进入命令页面了

测试

输入命令看是否执行成功

import tensorflow as tf
print(tf.__version__)

tf1版本中用此代码测试：

import tensorflow as tf
sess = tf.Session()
a = tf.constant(10)
b= tf.constant(12)
sess.run(a+b)

若出现22表明环境安装成功

tf2版本中⽤用以下代码测试：

import tensorflow as tf
tf.compat.v1.disable_eager_execution()
sess = tf.compat.v1.Session()
a = tf.constant(10)
b= tf.constant(12)
sess.run(a+b)

若出现22表明环境安装成功

我这里结果显示的是22，安装成功

Original: https://blog.csdn.net/PEABRAIND/article/details/123883430
Author: 独宠。
Title: tensorflow的详细安装（包含jupyter notebook）