【darknet源码】：解析cfg文件源码追踪

灰太狼 2022-05-17 00:11 278阅读 0赞

darknet源码中的cfg文件读取完之后还要解析，解析由函数**parse\_network\_cfg(cfgfile)**中的**parse\_xxx**系列函数搞定。  
主要流程为：  
1.make\_network:用于构建一个新网络  
2.parse\_net\_options:解析\[net\]层的各个参数以及操作  
3.parse\_xxx（如：parse\_convolutional）:解析cfg中的各个 \[xxx\]（如：\[convolutional\]）的各个参数以及操作。

##### 1.src/network.c/make\_network(int n) #####

上述代码中的**network**就是darknet框架中的网络的数据结构，详细请参看[darknet网络核心结构体][darknet]。

/* ** 新建一个空网络，并为网络中部分指针参数动态分配内存 ** 输入： n 神经网络层数 ** 说明： 该函数只为网络的三个指针参数动态分配了内存，并没有为所有指针参数分配内存 */
    network make_network(int n)
    {
        network net = {
       0};
        net.n = n;
        // 为每一层分配内存
        net.layers = calloc(net.n, sizeof(layer));
        net.seen = calloc(1, sizeof(int));
        net.cost = calloc(1, sizeof(float));
        return net;
    }

##### 2.src/parser.c/parse\_net\_options(list \*options, network \*net) #####

void parse_net_options(list *options, network *net)
    {
        // 从.cfg网络参数配置文件中读入一些通用的网络配置参数，option_find_int()以及option_find_float()函数的第三个参数都是默认值（如果配置文件中没有设置该参数的值，就取默认值）
        // 稍微提一下batch这个参数，首先读入的net->batch是真实batch值，即每个batch中包含的照片张数，而后又读入一个subdivisions参数，这个参数暂时还没搞懂有什么用，
        // 总之最终的net->batch = net->batch / net->subdivisions
        net->batch = option_find_int(options, "batch",1);
        net->learning_rate = option_find_float(options, "learning_rate", .001);
        net->momentum = option_find_float(options, "momentum", .9);
        net->decay = option_find_float(options, "decay", .0001);
        int subdivs = option_find_int(options, "subdivisions",1);
        net->time_steps = option_find_int_quiet(options, "time_steps",1);
        net->notruth = option_find_int_quiet(options, "notruth",0);
        net->batch /= subdivs;
        net->batch *= net->time_steps;
        net->subdivisions = subdivs;
    
        net->adam = option_find_int_quiet(options, "adam", 0);
        if(net->adam){
            net->B1 = option_find_float(options, "B1", .9);
            net->B2 = option_find_float(options, "B2", .999);
            net->eps = option_find_float(options, "eps", .00000001);
        }
    
        net->h = option_find_int_quiet(options, "height",0);
        net->w = option_find_int_quiet(options, "width",0);
        net->c = option_find_int_quiet(options, "channels",0);
    
        // 一张输入图片的元素个数，如果网络配置文件没有指定，则默认值为net->h * net->w * net->c
        net->inputs = option_find_int_quiet(options, "inputs", net->h * net->w * net->c);
        net->max_crop = option_find_int_quiet(options, "max_crop",net->w*2);
        net->min_crop = option_find_int_quiet(options, "min_crop",net->w);
        net->center = option_find_int_quiet(options, "center",0);
    
        net->angle = option_find_float_quiet(options, "angle", 0);
        net->aspect = option_find_float_quiet(options, "aspect", 1);
        net->saturation = option_find_float_quiet(options, "saturation", 1);
        net->exposure = option_find_float_quiet(options, "exposure", 1);
        net->hue = option_find_float_quiet(options, "hue", 0);
    
        if(!net->inputs && !(net->h && net->w && net->c)) error("No input parameters supplied");
    
        char *policy_s = option_find_str(options, "policy", "constant");
        net->policy = get_policy(policy_s);
        net->burn_in = option_find_int_quiet(options, "burn_in", 0);
        net->power = option_find_float_quiet(options, "power", 4);
        if(net->policy == STEP){
            net->step = option_find_int(options, "step", 1);
            net->scale = option_find_float(options, "scale", 1);
        } else if (net->policy == STEPS){
            char *l = option_find(options, "steps");   
            char *p = option_find(options, "scales");   
            if(!l || !p) error("STEPS policy must have steps and scales in cfg file");
    
            int len = strlen(l);
            int n = 1;
            int i;
            for(i = 0; i < len; ++i){
                if (l[i] == ',') ++n;
            }
            int *steps = calloc(n, sizeof(int));
            float *scales = calloc(n, sizeof(float));
            for(i = 0; i < n; ++i){
                int step    = atoi(l);
                float scale = atof(p);
                l = strchr(l, ',')+1;
                p = strchr(p, ',')+1;
                steps[i] = step;
                scales[i] = scale;
            }
            net->scales = scales;
            net->steps = steps;
            net->num_steps = n;
        } else if (net->policy == EXP){
            net->gamma = option_find_float(options, "gamma", 1);
        } else if (net->policy == SIG){
            net->gamma = option_find_float(options, "gamma", 1);
            net->step = option_find_int(options, "step", 1);
        } else if (net->policy == POLY || net->policy == RANDOM){
        }
        net->max_batches = option_find_int(options, "max_batches", 0);
    }

##### 3.src/parser.c/parse\_convolutional(list \*options, size\_params params) #####

convolutional_layer parse_convolutional(list *options, size_params params)
    {
        // 获取卷积核个数，若配置文件中没有指定，则设为1
        int n = option_find_int(options, "filters",1);
        // 获取卷积核尺寸，若配置文件中没有指定，则设为1
        int size = option_find_int(options, "size",1);
        // 获取跨度，若配置文件中没有指定，则设为1
        int stride = option_find_int(options, "stride",1);
        // 是否在输入图像四周补0,若需要补0,值为1；若配置文件中没有指定，则设为0,不补0
        int pad = option_find_int_quiet(options, "pad",0);
        // 四周补0的长读，下面这句代码多余，有if(pad)这句就够了
        int padding = option_find_int_quiet(options, "padding",0);
        if(pad) padding = size/2;   // 如若需要补0,补0长度为卷积核一半长度（往下取整），这对应same补0策略
    
        // 获取该层使用的激活函数类型，若配置文件中没有指定，则使用logistic激活函数
        char *activation_s = option_find_str(options, "activation", "logistic");
        ACTIVATION activation = get_activation(activation_s);
    
        // h,w,c为上一层的输出的高度/宽度/通道数（第一层的则是输入的图片的尺寸与通道数，也即net.h,net.w,net.c），batch所有层都一样（不变），
        // params.h,params.w,params.c及params.inputs在构建每一层之后都会更新为上一层相应的输出参数（参见parse_network_cfg()）
        int batch,h,w,c;
        h = params.h;
        w = params.w;
        c = params.c;
        batch=params.batch;
    
        // 如果这三个数存在0值，那肯定有问题了，因为上一层（或者输入）必须不为0
        if(!(h && w && c)) error("Layer before convolutional layer must output image.");
        // 是否进行规范化，1表示进行规范化，若配置文件中没有指定，则设为0,即默认不进行规范化
        int batch_normalize = option_find_int_quiet(options, "batch_normalize", 0);
        // 是否对权重进行二值化，1表示进行二值化，若配置文件中没有指定，则设为0,即默认不进行二值化
        int binary = option_find_int_quiet(options, "binary", 0);
        // 是否对权重以及输入进行二值化，1表示是，若配置文件中没有指定，则设为0,即默认不进行二值化
        int xnor = option_find_int_quiet(options, "xnor", 0);
    
        //以上已经获取到了构建一层卷积层的所有参数，现在可以用这些参数构建卷积层了
        convolutional_layer layer = make_convolutional_layer(batch,h,w,c,n,size,stride,padding,activation, batch_normalize, binary, xnor, params.net.adam);
        layer.flipped = option_find_int_quiet(options, "flipped", 0);
        layer.dot = option_find_float_quiet(options, "dot", 0);
        if(params.net.adam){
            layer.B1 = params.net.B1;
            layer.B2 = params.net.B2;
            layer.eps = params.net.eps;
        }
    
        return layer;
    }

[darknet]: https://blog.csdn.net/qiu931110/article/details/81387483