【darknet源码】：读取cfg文件源码追踪

布满荆棘的人生 2022-05-16 23:55 202阅读 0赞

darknet源码中的cfg文件读取由函数**parse\_network\_cfg(cfgfile)**中的**read\_cfg(file)**函数搞定。  
如下代码所示，最终解析后的属性和参数保存于section：

network parse_network_cfg(char *filename)
    {
        // 从神经网络结构参数文件中读入所有神经网络层的结构参数，
        // 存储到sections中，
        // sections的每个node包含一层神经网络的所有结构参数
        list *sections = read_cfg(filename);

具体来说每一层（cfg中的每一层）都保存在结构体section中：  
定义于src/parser.c

typedef struct{
        char *type;//保存了cfg中层的名字
        list *options;//保存了当前层对应的参数
    }section;

而对应层的参数主要用到的结构是list结构：  
定义于src/list.c文件中：

list *make_list()
    {
        list *l = malloc(sizeof(list));
        l->size = 0;
        l->front = 0;
        l->back = 0;
        return l;
    }

主要流程为：  
1. 读取type流程  
**parse\_network\_cfg(cfgfile)**—>**read\_cfg(file)**—>**list\_insert(sections, current)**  
2. 读取对应type下的属性和数据  
**parse\_network\_cfg(cfgfile)**—>**read\_cfg(file)**—>**read\_option**–>**option\_insert**—>**list\_insert**

#### 读取type流程代码 ####

##### 1.0 src/parser.c/parese\_network\_cfg #####

network parse_network_cfg(char *filename)
    {
        // 从神经网络结构参数文件中读入所有神经网络层的结构参数，存储到sections中，
        // sections的每个node包含一层神经网络的所有结构参数
        list *sections = read_cfg(filename);
    
        // 获取sections的第一个节点，可以查看一下cfg/***.cfg文件，其实第一块参数（以[net]开头）不是某层神经网络的参数，
        // 而是关于整个网络的一些通用参数，比如学习率，衰减率，输入图像宽高，batch大小等，
        // 具体的关于某个网络层的参数是从第二块开始的，如[convolutional],[maxpool]...，
        // 这些层并没有编号，只说明了层的属性，但层的参数都是按顺序在文件中排好的，读入时，
        // sections链表上的顺序就是文件中的排列顺序。
        node *n = sections->front;
        if(!n) error("Config file has no sections");
    
        // 创建网络结构并动态分配内存：输入网络层数为sections->size - 1，sections的第一段不是网络层，而是通用网络参数
        network net = make_network(sections->size - 1);
    
        // 所用显卡的卡号（gpu_index在cuda.c中用extern关键字声明）
        // 在调用parse_network_cfg()之前，使用了cuda_set_device()设置了gpu_index的值号为当前活跃GPU卡号
        net.gpu_index = gpu_index;
    
        // size_params结构体元素不含指针变量
        size_params params;
    
        // 提取
        section *s = (section *)n->val;
        list *options = s->options;
        if(!is_network(s)) error("First section must be [net] or [network]");
        parse_net_options(options, &net);
    
        params.h = net.h;
        params.w = net.w;
        params.c = net.c;
        params.inputs = net.inputs;
        params.batch = net.batch;
        params.time_steps = net.time_steps;
        params.net = net;
    
        size_t workspace_size = 0;
        n = n->next;
        int count = 0;
        free_section(s);
    
        // 此处stderr不是错误提示，而是输出结果提示，提示网络结构
        fprintf(stderr, "layer filters size input output\n");
        while(n){
            params.index = count;
            fprintf(stderr, "%5d ", count);
            s = (section *)n->val;
            options = s->options;
            // 定义网络层
            layer l = {
       0};
            // 获取网络层的类别
            LAYER_TYPE lt = string_to_layer_type(s->type);
            if(lt == CONVOLUTIONAL){
                l = parse_convolutional(options, params);
            }else if(lt == DECONVOLUTIONAL){
                l = parse_deconvolutional(options, params);
            }else if(lt == LOCAL){
                l = parse_local(options, params);
            }else if(lt == ACTIVE){
                l = parse_activation(options, params);
            }else if(lt == RNN){
                l = parse_rnn(options, params);
            }else if(lt == GRU){
                l = parse_gru(options, params);
            }else if(lt == CRNN){
                l = parse_crnn(options, params);
            }else if(lt == CONNECTED){
                l = parse_connected(options, params);
            }else if(lt == CROP){
                l = parse_crop(options, params);
            }else if(lt == COST){
                l = parse_cost(options, params);
            }else if(lt == REGION){
                l = parse_region(options, params);
            }else if(lt == DETECTION){
                l = parse_detection(options, params);
            }else if(lt == SOFTMAX){
                l = parse_softmax(options, params);
                net.hierarchy = l.softmax_tree;
            }else if(lt == NORMALIZATION){
                l = parse_normalization(options, params);
            }else if(lt == BATCHNORM){
                l = parse_batchnorm(options, params);
            }else if(lt == MAXPOOL){
                l = parse_maxpool(options, params);
            }else if(lt == REORG){
                l = parse_reorg(options, params);
            }else if(lt == AVGPOOL){
                l = parse_avgpool(options, params);
            }else if(lt == ROUTE){
                l = parse_route(options, params, net);
            }else if(lt == SHORTCUT){
                l = parse_shortcut(options, params, net);
            }else if(lt == DROPOUT){
                l = parse_dropout(options, params);
                l.output = net.layers[count-1].output;
                l.delta = net.layers[count-1].delta;
    #ifdef GPU
                l.output_gpu = net.layers[count-1].output_gpu;
                l.delta_gpu = net.layers[count-1].delta_gpu;
    #endif
            }else{
                fprintf(stderr, "Type not recognized: %s\n", s->type);
            }
            l.truth = option_find_int_quiet(options, "truth", 0);
            l.onlyforward = option_find_int_quiet(options, "onlyforward", 0);
            l.stopbackward = option_find_int_quiet(options, "stopbackward", 0);
            l.dontload = option_find_int_quiet(options, "dontload", 0);
            l.dontloadscales = option_find_int_quiet(options, "dontloadscales", 0);
            l.learning_rate_scale = option_find_float_quiet(options, "learning_rate", 1);
            l.smooth = option_find_float_quiet(options, "smooth", 0);
            option_unused(options);
            net.layers[count] = l;
            if (l.workspace_size > workspace_size) workspace_size = l.workspace_size;
            free_section(s);
            n = n->next;
            ++count;
            // 构建每一层之后，如果之后还有层，则更新params.h,params.w,params.c及params.inputs为上一层相应的输出参数
            if(n){
                params.h = l.out_h;
                params.w = l.out_w;
                params.c = l.out_c;
                params.inputs = l.outputs;
            }
        }   
        free_list(sections);
        layer out = get_network_output_layer(net);
        net.outputs = out.outputs;
        net.truths = out.outputs;
        if(net.layers[net.n-1].truths) net.truths = net.layers[net.n-1].truths;
        net.output = out.output;
        net.input = calloc(net.inputs*net.batch, sizeof(float));
        net.truth = calloc(net.truths*net.batch, sizeof(float));
    #ifdef GPU
        net.output_gpu = out.output_gpu;
        net.input_gpu = cuda_make_array(net.input, net.inputs*net.batch);
        net.truth_gpu = cuda_make_array(net.truth, net.truths*net.batch);
    #endif
        if(workspace_size){
            //printf("%ld\n", workspace_size);
    #ifdef GPU
            if(gpu_index >= 0){
                net.workspace = cuda_make_array(0, (workspace_size-1)/sizeof(float)+1);
            }else {
                net.workspace = calloc(1, workspace_size);
            }
    #else
            net.workspace = calloc(1, workspace_size);
    #endif
        }
        return net;
    }

##### 1.1 src/parser.c/read\_cfg() #####

/* ** 读取神经网络结构配置文件（.cfg文件）中的配置数据，将每个神经网络层参数读取到每个section结构体中， ** （每个section是sections的一个节点）而后全部插入到list结构体sections中并返回 ** 输入： filename C风格字符数组，神经网络结构配置文件路径 ** 返回： list结构体指针，包含从神经网络结构配置文件中读入的所有神经网络层的参数 */
    list *read_cfg(char *filename)
    {
        // C风格文件流，"r"，只读模式，要求filename必须存在，否则返回空指针
        FILE *file = fopen(filename, "r");
        if(file == 0) file_error(filename);
        char *line;
        int nu = 0;
    
        // 动态分配list对象内存，并初始化sections所有元素值为0
        // sections包含所有的section，也即包含所有的神经网络层参数
        list *sections = make_list();
    
        // 一个section表示配置文件中的一个字段，也就是对应神经网络结构中的一层
        // 因此，一个section将读取并存储某一层的参数以及该层的类别名
        section *current = 0;
    
        // 调用fgetl读取文件中的一行（返回字符数组指针）
        while((line=fgetl(file)) != 0){
            ++ nu;
    
            // 去除读入行中可能含有的空白符
            strip(line);
            switch(line[0]){
                // 以[开头的行是层的类别说明，比如[net],[maxpool],[convolutional]之类的
                case '[':
                    // 动态分配一个section内存给current
                    current = malloc(sizeof(section));
                    // 将单个section current插入section集合sections中
                    list_insert(sections, current);
                    // 进一步动态的为current的元素options动态分配内存
                    current->options = make_list();
                    // 以[开头的是层的类别，赋值给type
                    current->type = line;
                    break;
                // 一下三种情况是无效行，直接释放内存即可（以#开头的是注释）
                case '\0':
                case '#':
                case ';':
                    free(line);
                    break;
    
                // 剩下的才真正是网络结构的数据，调用read_option()函数读取
                // 返回0说明文件中的数据格式有问题，将会提示错误
                default:
                    if(!read_option(line, current->options)){
                        fprintf(stderr, "Config file error line %d, could parse: %s\n", nu, line);
                        // C语言释放堆内存（动态分配的内存）：动态分配的内存一定要及时释放
                        free(line);
                    }
                    break;
            }
        }
        fclose(file);
        return sections;
    }

##### 1.2 src/list.c/list\_insert() #####

/* ** 将val指针插入list结构体l中，这里相当于是用C实现了C++中的list的元素插入功能 ** 流程： list中并不直接含有void*类型指针，但list中含有的node指针含有void*类型指针， ** 因此，将首先创建一个node指针new，而后将val传给new，最后再把new插入list指针l中 ** 说明： void*指针可以接收不同数据类型的指针，因此第二个参数具体是什么类型的指针得视情况而定 ** 调用： 该函数在众多地方调用，很多从文件中读取信息存入到list变量中，都会调用此函数， ** 注意此函数类似C++的insert()插入方式；而在option_list.h中的opion_insert()函数， ** 有点类似C++ map数据结构中的按值插入方式，比如map[key]=value，两个函数操作对象都是list变量， ** 只是操作方式略有不同。 */
    void list_insert(list *l, void *val)
    {
        // 定义一个node指针并动态分配内存
        node *new = malloc(sizeof(node));
        // 将输入的val指针赋值给new中的val元素，注意，这是指针复制，共享地址，二者都是void*类型指针
        new->val = val;
        new->next = 0;
    
        // 下面的链表嵌套主要注意一下
        // 如果l的back元素为空指针，说明l到目前为止，还没有存入数据（只是在函数外动态分配了内存，并没有赋有效值），
        // 这样，令l的front为new（此后front将不会再变，除非删除），显然此时new的前面没有node，因此new->prev=0
        if(!l->back){
            l->front = new;
            new->prev = 0;
        }else{
            // 如果已经插入了第一个元素，那么往下嵌套，注意这里操作的是指针，互有影响
            // 新插入的node赋给back的下一个node next，
            // 同时对于新的node new来说，其前一个node为l->back
            // 一定注意要相互更新（链表上的数据位置关系都是相对的）
            l->back->next = new;
            new->prev = l->back;
        }
        // 更新back的值
        // 不管前面进行了什么操作，每次插入new，都必须更新l的back为当前new，因为链表结构，
        // 新插入的元素永远在最后，此处back就是链表中的最后一个元素，front是链表中的第一个元素，
        // 链表中的第一个元素在第一次插入元素之后将不会再变（除非删除）
        l->back = new;
        // l中存储的元素个数加1
        ++l->size;
    }

#### 读取对应type下的属性和数据 ####

##### 2.0 src/parser.c/parese\_network\_cfg #####

##### 2.1 src/parser.c/read\_cfg() #####

##### 2.2 src/option\_list.c/read\_option() #####

/* ** 解析一行数据的内容，为options赋值，主要调用option_insert() ** 输入：s 从文件读入的某行字符数组指针 ** options 实际输出，解析出的数据将为该变量赋值 ** 返回：int类型数据，1表示成功读取有效数据，0表示未能读取有效数据（说明文件中数据格式有问题） ** 流程：从配置（.data或者.cfg，不管是数据配置文件还是神经网络结构数据文件，其读取都需要调用这个函数） ** 文件中读入的每行数据包括两部分，第一部分为变量名称，如learning_rate， ** 第二部分为值，如0.01，两部分由=隔开，因此，要分别读入两部分的值，首先识别出 ** 等号，获取等号所在的指针，并将等号替换为terminating null-characteristic '\0'， ** 这样第一部分会自动识别到'\0'停止，而第二部分则从等号下一个地方开始 */
    int read_option(char *s, list *options)
    {
        size_t i;
        size_t len = strlen(s);
        char *val = 0;
        for(i = 0; i < len; ++i){
            // 找出=的偏移位
            if(s[i] == '='){
                //将等号替换为'\0'，作为第一部分的终止符
                s[i] = '\0';
                // 第二部分字符数组的起始指针
                val = s+i+1;
                break;
            }
        }
        // 如果i==len-1，说明没有找到等号这个符号，那么就直接返回0（文件中还有一些注释，此外还有用[]括起来的字符，这些是网络层的类别或者名字，比如[maxpool]表示这些是池化层的参数）
        if(i == len-1) return 0;
        char *key = s;
        // 调用option_insert为options赋值，类比C++中的map数据结构，key相当是键值（变量名），
        // 而val则是值（变量的值）
        option_insert(options, key, val);
        return 1;
    }

##### 2.3 src/option\_list.c/option\_insert() #####

/* ** 将输入key和val赋值给kvp结构体对象，最终调用list_insert()将kvp赋值给list对象l， ** 完成最后的赋值（此函数之后，文件中某行的数据真正读入进list变量） ** 说明： 这个函数有点类似C++中按键值插入元素值的功能 ** 输入：l 输出，最终被赋值的list变量 ** key 变量的名称，C风格字符数组 ** value 变量的值，C风格字符数组（还未转换成float或者double数据类型） */
    void option_insert(list *l, char *key, char *val)
    {
        // kvp也是一个结构体，包含两个C风格字符数组指针：key和val，对应键值和值，
        // 此处key为变量名，val为变量的值（比如类别数，路径名称，注意都是字符类型数据）
        kvp *p = malloc(sizeof(kvp));
        p->key = key;
        p->val = val;
        p->used = 0;
        list_insert(l, p);
    }

##### 2.4 src/list.c/list\_insert() #####