【代码解析（4）】Communication-Efficient Learning of Deep Networks from Decentralized Data

options.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Python version: 3.6

import argparse  # 引入模块


def args_parser():
    # 建立解析对象
    parser = argparse.ArgumentParser()

    '''
       联邦学习参数 
    '''
    '''
        给一个 ArgumentParser 添加程序参数信息是通过调用 
        add_argument() 方法完成的。通常，这些调用指定 
        ArgumentParser 如何获取命令行字符串并将其转换为对象。
        这些信息在 parse_args() 调用时被存储和使用。
    
    '''
    # federated arguments (Notation for the arguments followed from paper)
    # epoch=10
    parser.add_argument('--epochs', type=int, default=10,
                        help="number of rounds of training")
    # num_users=100个用户
    parser.add_argument('--num_users', type=int, default=100,
                        help="number of users: K")
    # 每一轮的开始，随机选择一部分客户端，这一部分取决于C-小数
    # 所选择的客户端利用所有数据计算损失的梯度
    # C=0.1, 100*0.1=10，
    parser.add_argument('--frac', type=float, default=0.1,
                        help='the fraction of clients: C')

    # 本地epoch=10
    parser.add_argument('--local_ep', type=int, default=10,
                        help="the number of local epochs: E")

    # 本地batch_size=10
    parser.add_argument('--local_bs', type=int, default=10,
                        help="local batch size: B")

    # 学习率=0.01
    parser.add_argument('--lr', type=float, default=0.01,
                        help='learning rate')

    # 动量0.5
    parser.add_argument('--momentum', type=float, default=0.5,
                        help='SGD momentum (default: 0.5)')

    '''
        模型参数 
    '''
    # model arguments
    # 选择模型，默认为MLP

    parser.add_argument('--model', type=str, default='mlp', help='model name')

    # kernel数量为9
    parser.add_argument('--kernel_num', type=int, default=9,
                        help='number of each kind of kernel')

    # kernel大小3*3， 4*4， 5*5 for cnn
    parser.add_argument('--kernel_sizes', type=str, default='3,4,5',
                        help='comma-separated kernel size to \
                        use for convolution')

    # 通道数量，图片通道channel=1，因为是灰度图，不是rgb
    parser.add_argument('--num_channels', type=int, default=1, help="number \
                        of channels of imgs")

    # batch_norm加速神经网络的训练，加速收敛速度及稳定性
    # layer_norm
    '''
        LN是和BN非常近似的一种归一化方法，
        不同的是BN取的是不同样本的同一个特征，
        而LN取的是同一个样本的不同特征。
        在BN和LN都能使用的场景中，
        BN的效果一般优于LN，
        原因是基于不同数据，
        同一特征得到的归一化特征更不容易损失信息。
        
        将LN添加到CNN之后，实验结果发现LN破坏了
        卷积学习到的特征，模型无法收敛，
        所以在CNN之后使用BN是一个更好的选择。
    '''
    parser.add_argument('--norm', type=str, default='batch_norm',
                        help="batch_norm, layer_norm, or None")

    # cnn中过滤器数量=32
    '''
        卷积核与过滤器区别：
            对于单通道图片，过滤器=卷积核，得到的一个特征图对应一个卷积核
            对于多通道图片，过滤器=卷积核的集合，得到的一个特征图对应一个过滤器
            
            
        卷积核就是由长和宽来指定的，是一个二维的概念。

        而过滤器是是由长、宽和深度指定的，是一个三维的概念。
        
        过滤器可以看做是卷积核的集合。
        
        过滤器比卷积核高一个维度——深度。
    '''
    parser.add_argument('--num_filters', type=int, default=32,
                        help="number of filters for conv nets -- 32 for \
                        mini-imagenet, 64 for omiglot.")

    # max_pooling是否利用最大池化
    parser.add_argument('--max_pool', type=str, default='True',
                        help="Whether use max pooling rather than \
                        strided convolutions")

    # other arguments
    # 数据集选择 default='mnist'
    parser.add_argument('--dataset', type=str, default='cifar', help="name \
                        of dataset")

    # ？？
    '''
        cifar：32*32*3
        数据集由10类图片组成
        飞机， 汽车， 鸟， 猫， 鹿， 狗， 青蛙， 马， 船，卡车。
    '''
    parser.add_argument('--num_classes', type=int, default=10, help="number \
                        of classes")
    '''
    parser.add_argument('--gpu', default=None, help="To use cuda, set \
                        to a specific GPU ID. Default set to use CPU.")
    '''
    # CPU or GPU 0 default=None无值为false
    parser.add_argument('--gpu', default=0, help="To use cuda, set \
                            to a specific GPU ID. Default set to use CPU.")

    # 优化器策略：SGD or Adam?
    parser.add_argument('--optimizer', type=str, default='sgd', help="type \
                        of optimizer")

    # 客户端之间数据是IID还是non-IID
    parser.add_argument('--iid', type=int, default=1,
                        help='Default set to IID. Set to 0 for non-IID.')

    # 客户端之间数据均等划分与否
    parser.add_argument('--unequal', type=int, default=0,
                        help='whether to use unequal data splits for  \
                        non-i.i.d setting (use 0 for equal splits)')

    # 训练轮数
    parser.add_argument('--stopping_rounds', type=int, default=10,
                        help='rounds of early stopping')

    # 冗长
    parser.add_argument('--verbose', type=int, default=1, help='verbose')

    # 随机种子
    parser.add_argument('--seed', type=int, default=1, help='random seed')
    args = parser.parse_args()
    return args