YOLOv3：Darknet代码解析（二）代码初步

水深无声 2022-05-20 00:47 290阅读 0赞

**背景：**我们在linux上安装了DarkNet。

**目的：**初步解读darknet源码

[YOLOv3：Darknet代码解析（一）安装Darknet][YOLOv3_Darknet_Darknet]

[YOLOv3：Darknet代码解析（二）代码初步][YOLOv3_Darknet]

[YOLOv3：Darknet代码解析（三）卷积操作][YOLOv3_Darknet 1]

[YOLOv3：Darknet代码解析（四）结构更改与训练][YOLOv3_Darknet 2]

[YOLOv3：Darknet代码解析（五）权重与特征存储][YOLOv3_Darknet 3]

[YOLOv3：Darknet代码解析（六）简化的程序与卷积拆分][YOLOv3_Darknet 4]

**目录**

1. srand(time(0));

1.1 srand(unsigned seed)

1.2 time(0)

1.3 clock()

2. Thread

3.结构体中.与->的区别

4.堆与栈

5. enum

6.结构体中的指针

7. \#pragma

8.  运行tiny\_yolo相关代码

8.1 主函数相关

--------------------

yolo.c

//run_yolo
    void run_yolo(int argc, char **argv)
    {
        char *prefix = find_char_arg(argc, argv, "-prefix", 0);
        float thresh = find_float_arg(argc, argv, "-thresh", .2);
        int cam_index = find_int_arg(argc, argv, "-c", 0);
        int frame_skip = find_int_arg(argc, argv, "-s", 0);
        if(argc < 4){
            fprintf(stderr, "usage: %s %s [train/test/valid] [cfg] [weights (optional)]\n", argv[0], argv[1]);
            return;
        }
    
        int avg = find_int_arg(argc, argv, "-avg", 1);
        char *cfg = argv[3];
        char *weights = (argc > 4) ? argv[4] : 0;
        char *filename = (argc > 5) ? argv[5]: 0;
        if(0==strcmp(argv[2], "test")) test_yolo(cfg, weights, filename, thresh);
        else if(0==strcmp(argv[2], "train")) train_yolo(cfg, weights);
        else if(0==strcmp(argv[2], "valid")) validate_yolo(cfg, weights);
        else if(0==strcmp(argv[2], "recall")) validate_yolo_recall(cfg, weights);
        else if(0==strcmp(argv[2], "demo")) demo(cfg, weights, thresh, cam_index, filename, voc_names, 20, frame_skip, prefix, avg, .5, 0,0,0,0);
    }

训练函数

//train_yolo
    void train_yolo(char *cfgfile, char *weightfile)
    {
        char *train_images = "/data/voc/train.txt";
        char *backup_directory = "/home/pjreddie/backup/";
        srand(time(0));
        char *base = basecfg(cfgfile);
        printf("%s\n", base);
        float avg_loss = -1;
        network *net = load_network(cfgfile, weightfile, 0);
        printf("Learning Rate: %g, Momentum: %g, Decay: %g\n", net->learning_rate, net->momentum, net->decay);
        int imgs = net->batch*net->subdivisions;
        int i = *net->seen/imgs;
        data train, buffer;
    
    
        layer l = net->layers[net->n - 1];
    
        int side = l.side;
        int classes = l.classes;
        float jitter = l.jitter;
    
        list *plist = get_paths(train_images);
        //int N = plist->size;
        char **paths = (char **)list_to_array(plist);
    
        load_args args = {0};
        args.w = net->w;
        args.h = net->h;
        args.paths = paths;
        args.n = imgs;
        args.m = plist->size;
        args.classes = classes;
        args.jitter = jitter;
        args.num_boxes = side;
        args.d = &buffer;
        args.type = REGION_DATA;
    
        args.angle = net->angle;
        args.exposure = net->exposure;
        args.saturation = net->saturation;
        args.hue = net->hue;
    
        pthread_t load_thread = load_data_in_thread(args);
        clock_t time;
        //while(i*imgs < N*120){
        while(get_current_batch(net) < net->max_batches){
            i += 1;
            time=clock();
            pthread_join(load_thread, 0);
            train = buffer;
            load_thread = load_data_in_thread(args);
    
            printf("Loaded: %lf seconds\n", sec(clock()-time));
    
            time=clock();
            float loss = train_network(net, train);
            if (avg_loss < 0) avg_loss = loss;
            avg_loss = avg_loss*.9 + loss*.1;
    
            printf("%d: %f, %f avg, %f rate, %lf seconds, %d images\n", i, loss, avg_loss, get_current_rate(net), sec(clock()-time), i*imgs);
            if(i%1000==0 || (i < 1000 && i%100 == 0)){
                char buff[256];
                sprintf(buff, "%s/%s_%d.weights", backup_directory, base, i);
                save_weights(net, buff);
            }
            free_data(train);
        }
        char buff[256];
        sprintf(buff, "%s/%s_final.weights", backup_directory, base);
        save_weights(net, buff);
    }

# 1. **srand(time(0));** #

## 1.1 srand(unsigned seed) ##

通过参数seed改变系统提供的种子值，从而可以使得每次调用rand函数生成的伪随机数序列不同，从而实现真正意义上的“随机”。通常可以利用系统时间来改变系统的种子值，即srand(time(NULL))，可以为rand函数提供不同的种子值，进而产生不同的随机数序列

srand和[rand()][rand]配合使用产生伪[随机数][Link 1]序列。

## 1.2 time(0) ##

时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数

在C语言中可以通过time()函数获取到当前的秒数 参数为0则函数返回值即为结果，若参数不为0则结果保存在参数中

## 1.3 clock() ##

clock()是C/C++中的计时函数，而与其相关的数据类型是clock\_t。clock\_t clock(void) ;该程序从启动到函数调用占用CPU的时间。这个函数返回从“开启这个程序进程”到“程序中调用clock()函数”时之间的CPU时钟计时单元（clock tick）数，在MSDN中称之为挂钟时间（wal-clock）；若挂钟时间不可取，则返回-1。其中clock\_t是用来保存时间的数据类型。

//example about clock
    #include<time.h>
    #include<stdio.h>
    #include<windows.h>
    int main()
    {
    	int h=0,m=0,s=0;
    	int t=0;
    	while(1)
    	{
    		t=time(0);  //获取总秒数	 
    		s=t%60;
    		m=t%3600/60;	//1h= 3600s不足1h的除60即为分钟	 
    		h=(t%(24*3600)/3600+8)%24; //1天24h 得到当天小时数+8为东八区区时 避免出现大于24h的情况对24取余 
    		 
    		printf("%02d:%02d:%02d\r",h,m,s); // %02d是将数字按宽度为2，采用右对齐方式输出，若数据位数不到2位，则左边补0 \r到当前行最左 
    		//while(t==time(0)); 
    		Sleep(1000);//程序执行较快 对时间进行控制 执行挂起1s 
    	}
    	return 0;
     }

# **2. Thread** #

线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令[指针][Link 2](PC），[寄存器][Link 3]集合和[堆栈][Link 4]组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有[就绪][Link 5]、[阻塞][Link 6]和[运行][Link 7]三种基本状态。就绪状态是指线程具备运行的所有条件，逻辑上可以运行，在等待处理机；运行状态是指线程占有处理机正在运行；阻塞状态是指线程在等待一个事件（如某个信号量），逻辑上不可执行。每一个程序都至少有一个线程，若程序只有一个线程，那就是程序本身。

线程是程序中一个单一的顺序控制流程。进程内有一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指令[运行][Link 8]时的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为[多线程][Link 9]。

layer make_yolo_layer(int batch, int w, int h, int n, int total, int *mask, int classes)
    {
        int i;
        layer l = {0};
        l.type = YOLO;
    
        l.n = n;
        l.total = total;
        l.batch = batch;
        l.h = h;
        l.w = w;
        l.c = n*(classes + 4 + 1);
        l.out_w = l.w;
        l.out_h = l.h;
        l.out_c = l.c;
        l.classes = classes;
        l.cost = calloc(1, sizeof(float));
        l.biases = calloc(total*2, sizeof(float));
        if(mask) l.mask = mask;
        else{
            l.mask = calloc(n, sizeof(int));
            for(i = 0; i < n; ++i){
                l.mask[i] = i;
            }
        }
        l.bias_updates = calloc(n*2, sizeof(float));
        l.outputs = h*w*n*(classes + 4 + 1);
        l.inputs = l.outputs;
        l.truths = 90*(4 + 1);
        l.delta = calloc(batch*l.outputs, sizeof(float));
        l.output = calloc(batch*l.outputs, sizeof(float));
        for(i = 0; i < total*2; ++i){
            l.biases[i] = .5;
        }
    
        l.forward = forward_yolo_layer;
        l.backward = backward_yolo_layer;
    #ifdef GPU
        l.forward_gpu = forward_yolo_layer_gpu;
        l.backward_gpu = backward_yolo_layer_gpu;
        l.output_gpu = cuda_make_array(l.output, batch*l.outputs);
        l.delta_gpu = cuda_make_array(l.delta, batch*l.outputs);
    #endif
    
        fprintf(stderr, "yolo\n");
        srand(0);
    
        return l;
    }
    
    void resize_yolo_layer(layer *l, int w, int h)
    {
        l->w = w;
        l->h = h;
    
        l->outputs = h*w*l->n*(l->classes + 4 + 1);
        l->inputs = l->outputs;
    
        l->output = realloc(l->output, l->batch*l->outputs*sizeof(float));
        l->delta = realloc(l->delta, l->batch*l->outputs*sizeof(float));
    
    #ifdef GPU
        cuda_free(l->delta_gpu);
        cuda_free(l->output_gpu);
    
        l->delta_gpu =     cuda_make_array(l->delta, l->batch*l->outputs);
        l->output_gpu =    cuda_make_array(l->output, l->batch*l->outputs);
    #endif
    }

# **3.结构体中.与->的区别** #

如果有个变量MyStruct s，那么使用其中的成员元素时可以用  
s.member\_a = 1;  
如果采用指针方法访问，比如MyStruct \* ps，那么同样的访问就必须使用如下形式：  
(\*ps).member\_a = 1;  
或者

ps->member\_a = 1;

定义如下：  
A \*p则：p->play()使用; 左边是结构指针。  
A p 则：p.paly()使用; 左边是结构变量。  
总结：  
箭头（->）：左边必须为指针；

点号（.）：左边必须为实体。

所以我们在创建层的时候用的是结构体layer l，在resize时只用对已有的layer改变其大小，所以用的是指针。layer \*l

# **4.堆与栈** #

数据结构中的堆与栈与操作系统中的堆与栈很不一样。直接声明的变量储存的区域叫做栈（stack），使用malloc获得的区域叫堆（heap）。

栈是连续高速而小的（1M，2M的都有，一般不超过2M），堆是不连续低速但容量极大的。

**什么是堆：**堆是大家共有的空间，分全局堆和局部堆。全局堆就是所有没有分配的空间，局部堆就是用户分配的空间。堆在操作系统对进程 初始化的时候分配，运行过程中也可以向系统要额外的堆，但是记得用完了要还给操作系统，要不然就是内存泄漏。

**什么是栈：**栈是线程独有的，保存其运行状态和局部自动变量的。栈在线程开始的时候初始化，每个线程的栈互相独立。每个函数都有自己的栈，栈被用来在函数之间传递参数。操作系统在切换线程的时候会自动的切换栈，就是切换SS/ESP寄存器。栈空间不需要在高级语言里面显式的分配和释放。

栈是由编译器自动分配释放，存放函数的参数值、局部变量的值等。操作方式类似于数据结构中的栈。

堆一般由程序员分配释放，若不释放，程序结束时可能由OS回收。也可能造成内存泄漏。

# **5. enum** #

enum是计算机编程语言中的一种数据类型。枚举类型：在实际问题中，有些变量的取值被限定在一个有限的范围内。例如，一个星期内只有七天，一年只有十二个月，一个班每周有六门课程等等。

枚举类型定义的一般形式为：

enum 枚举名\{ [枚举值][Link 10]表 \};

在枚举值表中应罗列出所有可用值。这些值也称为枚举元素。

如同结构体（struct）和共用体（union）一样，枚举变量也可用不同的方式说明，即先定义后说明，同时定义说明或直接说明。

设有变量a,b,c被说明为上述的weekday，可采用下述任一种方式：

enum weekday{sun,mon,tue,wed,thu,fri,sat};
    enum weekday a,b,c;
    //或者为：
    enum weekday{sun,mon,tue,wed,thu,fri,sat}a,b,c;
    //或者为：
    enum{sun,mon,tue,wed,thu,fri,sat}a,b,c;

//darknet.h
    typedef enum{
        LOGISTIC, RELU, RELIE, LINEAR, RAMP, TANH, PLSE, LEAKY, ELU, LOGGY, STAIR, HARDTAN, LHTAN
    } ACTIVATION;
    
    typedef enum{
        MULT, ADD, SUB, DIV
    } BINARY_ACTIVATION;

# **6.结构体中的指针** #

结构体中：

void (*forward)   (struct layer, struct network);

空指针即没有指向的指针，指向的地址是NULL**。**源码中**\#define NULL    ((void \*)0)**

void \*类型的指针是不确定类型的指针，其指向的内容不确定，后期一般会进行**强制类型转换**的。

# 7. \#pragma #

在所有的[预处理指令][Link 11]中，\#pragma 指令可能是最复杂的了，它的作用是设定[编译器][Link 12]的状态或者是指示编译器完成一些特定的动作。\#pragma指令对每个编译器给出了一个方法，在保持与C和C++语言完全兼容的情况下，给出主机或操作系统专有的特征。依据定义，编译指示是机器或操作系统专有的，且对于每个编译器都是不同的。

# 8.  运行tiny\_yolo相关代码 #

## 8.1 主函数相关 ##

我们的linux命令行为

./darknet detect cfg/yolov3-tiny.cfg yolov3-tiny.weights data/dog.jpg

[YOLOv3_Darknet_Darknet]: https://blog.csdn.net/weixin_36474809/article/details/80881043
[YOLOv3_Darknet]: https://blog.csdn.net/weixin_36474809/article/details/80975845
[YOLOv3_Darknet 1]: https://blog.csdn.net/weixin_36474809/article/details/81296612
[YOLOv3_Darknet 2]: https://blog.csdn.net/weixin_36474809/article/details/81326286
[YOLOv3_Darknet 3]: https://blog.csdn.net/weixin_36474809/article/details/81331175
[YOLOv3_Darknet 4]: https://blog.csdn.net/weixin_36474809/article/details/81739771
[rand]: https://baike.baidu.com/item/rand%28%29
[Link 1]: https://baike.baidu.com/item/%E9%9A%8F%E6%9C%BA%E6%95%B0
[Link 2]: https://baike.baidu.com/item/%E6%8C%87%E9%92%88/2878304
[Link 3]: https://baike.baidu.com/item/%E5%AF%84%E5%AD%98%E5%99%A8/187682
[Link 4]: https://baike.baidu.com/item/%E5%A0%86%E6%A0%88/1682032
[Link 5]: https://baike.baidu.com/item/%E5%B0%B1%E7%BB%AA/10932509
[Link 6]: https://baike.baidu.com/item/%E9%98%BB%E5%A1%9E/9032404
[Link 7]: https://baike.baidu.com/item/%E8%BF%90%E8%A1%8C/5480697
[Link 8]: https://baike.baidu.com/item/%E8%BF%90%E8%A1%8C
[Link 9]: https://baike.baidu.com/item/%E5%A4%9A%E7%BA%BF%E7%A8%8B/1190404
[Link 10]: https://baike.baidu.com/item/%E6%9E%9A%E4%B8%BE%E5%80%BC
[Link 11]: https://baike.baidu.com/item/%E9%A2%84%E5%A4%84%E7%90%86%E6%8C%87%E4%BB%A4/4752501
[Link 12]: https://baike.baidu.com/item/%E7%BC%96%E8%AF%91%E5%99%A8/8853067