compare
train_compare
void train_compare(char *cfgfile, char *weightfile)
{
srand(time(0));
float avg_loss = -1;
char *base = basecfg(cfgfile);
char *backup_directory = "/home/pjreddie/backup/";
printf("%s\n", base);
network net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
}
printf("Learning Rate: %g, Momentum: %g, Decay: %g\n", net.learning_rate, net.momentum, net.decay);
int imgs = 1024;
list *plist = get_paths("data/compare.train.list");
char **paths = (char **)list_to_array(plist);
int N = plist->size;
printf("%d\n", N);
clock_t time;
pthread_t load_thread;
data train;
data buffer;
load_args args = {0};
args.w = net.w;
args.h = net.h;
args.paths = paths;
args.classes = 20;
args.n = imgs;
args.m = N;
args.d = &buffer;
args.type = COMPARE_DATA;
load_thread = load_data_in_thread(args);
int epoch = *net.seen/N;
int i = 0;
while(1){
++i;
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 == -1) avg_loss = loss;
avg_loss = avg_loss*.9 + loss*.1;
printf("%.3f: %f, %f avg, %lf seconds, %ld images\n", (float)*net.seen/N, loss, avg_loss, sec(clock()-time), *net.seen);
free_data(train);
if(i%100 == 0){
char buff[256];
sprintf(buff, "%s/%s_%d_minor_%d.weights",backup_directory,base, epoch, i);
save_weights(net, buff);
}
if(*net.seen/N > epoch){
epoch = *net.seen/N;
i = 0;
char buff[256];
sprintf(buff, "%s/%s_%d.weights",backup_directory,base, epoch);
save_weights(net, buff);
if(epoch%22 == 0) net.learning_rate *= .1;
}
}
pthread_join(load_thread, 0);
free_data(buffer);
free_network(net);
free_ptrs((void**)paths, plist->size);
free_list(plist);
free(base);
}함수 이름: train_compare
입력:
char *cfgfile: 학습을 수행할 YOLO 모델의 구성 파일 경로
char *weightfile: 학습을 수행할 YOLO 모델의 가중치 파일 경로
동작:
YOLO 모델을 이용하여 compare_data 형식의 데이터를 학습한다.
지정된 횟수(epoch)만큼 학습을 반복하며, 학습 중에는 주기적으로 가중치 파일을 저장한다.
학습 종료 후, 학습된 YOLO 모델의 가중치를 저장한다.
설명:
srand(time(0))은 시간에 따라 랜덤 시드를 설정한다.
basecfg(cfgfile)은 cfgfile에서 파일 이름만 가져온다.
network net = parse_network_cfg(cfgfile)은 cfgfile에서 모델 구성 정보를 파싱하여 네트워크 모델을 생성한다.
load_weights(&net, weightfile)은 weightfile에서 저장된 가중치 정보를 로드하여 모델에 적용한다.
imgs는 한 번에 읽을 이미지 파일의 개수이다.
get_paths("data/compare.train.list")는 학습에 사용할 이미지 파일 경로 리스트를 읽어온다.
load_args 구조체를 초기화하고, load_data_in_thread(args)를 호출하여 이미지와 라벨 데이터를 비동기적으로 읽어온다.
train_network(net, train)은 모델(net)과 학습 데이터(train)를 이용하여 학습을 수행하고, 학습 손실값을 반환한다.
save_weights(net, buff)는 모델(net)의 가중치 정보를 buff 경로에 저장한다.
net.learning_rate *= .1은 학습률(learning_rate)을 10% 감소시킨다.
free_data(train)은 학습 데이터(train)를 해제한다.
free_network(net)은 모델(net)을 해제한다.
free_ptrs((void**)paths, plist->size)은 paths 배열과 plist 리스트를 해제한다.
free_list(plist)는 plist 리스트를 해제한다.
free(base)는 base 메모리를 해제한다.
validate_compare
void validate_compare(char *filename, char *weightfile)
{
int i = 0;
network net = parse_network_cfg(filename);
if(weightfile){
load_weights(&net, weightfile);
}
srand(time(0));
list *plist = get_paths("data/compare.val.list");
//list *plist = get_paths("data/compare.val.old");
char **paths = (char **)list_to_array(plist);
int N = plist->size/2;
free_list(plist);
clock_t time;
int correct = 0;
int total = 0;
int splits = 10;
int num = (i+1)*N/splits - i*N/splits;
data val, buffer;
load_args args = {0};
args.w = net.w;
args.h = net.h;
args.paths = paths;
args.classes = 20;
args.n = num;
args.m = 0;
args.d = &buffer;
args.type = COMPARE_DATA;
pthread_t load_thread = load_data_in_thread(args);
for(i = 1; i <= splits; ++i){
time=clock();
pthread_join(load_thread, 0);
val = buffer;
num = (i+1)*N/splits - i*N/splits;
char **part = paths+(i*N/splits);
if(i != splits){
args.paths = part;
load_thread = load_data_in_thread(args);
}
printf("Loaded: %d images in %lf seconds\n", val.X.rows, sec(clock()-time));
time=clock();
matrix pred = network_predict_data(net, val);
int j,k;
for(j = 0; j < val.y.rows; ++j){
for(k = 0; k < 20; ++k){
if(val.y.vals[j][k*2] != val.y.vals[j][k*2+1]){
++total;
if((val.y.vals[j][k*2] < val.y.vals[j][k*2+1]) == (pred.vals[j][k*2] < pred.vals[j][k*2+1])){
++correct;
}
}
}
}
free_matrix(pred);
printf("%d: Acc: %f, %lf seconds, %d images\n", i, (float)correct/total, sec(clock()-time), val.X.rows);
free_data(val);
}
}함수 이름: validate_compare
입력:
char* filename : 네트워크 설정 파일 경로
char* weightfile : 미리 학습된 가중치 파일 경로
동작:
네트워크 설정 파일과 미리 학습된 가중치 파일을 이용하여 네트워크를 불러온다.
검증 데이터셋 경로를 읽어온다.
검증 데이터셋을 10개로 분할하여 각각에 대해 다음을 수행한다.
검증 데이터를 읽어온다.
네트워크를 이용하여 예측을 수행한다.
예측값과 실제값을 비교하여 정확도를 계산한다.
분할된 각 검증 데이터셋에 대한 정확도와 소요 시간을 출력한다.
설명:
이 함수는 이미 학습된 네트워크를 검증하는 역할을 한다. 검증 데이터셋은 10개로 분할하여 각각에 대해 검증을 수행하고, 최종적으로 분할된 전체 검증 데이터셋에 대한 정확도와 소요 시간을 출력한다.
sortable_bbox
typedef struct {
network net;
char *filename;
int class;
int classes;
float elo;
float *elos;
} sortable_bbox;network net: YOLO 네트워크에 대한 정보가 담긴 구조체로, YOLO 객체 검출 모델에 대한 정보를 저장합니다.char *filename: 객체 검출이 수행된 이미지 파일의 경로를 저장합니다.int class: 객체가 속한 클래스의 인덱스를 저장합니다. 예를 들어, 클래스가 80개인 COCO 데이터셋에서는 0부터 79까지의 정수값으로 클래스를 표현합니다.int classes: 객체 검출 모델이 인식할 수 있는 클래스의 수를 저장합니다.float elo: 현재 객체 검출 결과에 대한 Elo rating 값을 저장합니다. Elo rating은 체스나 게임 등에서 플레이어의 능력치를 표현하기 위한 수치입니다.float *elos: 각 클래스에 대한 Elo rating 값을 저장합니다. classes와 같은 크기를 가지는 배열입니다.
이 구조체는 객체 검출 결과를 저장하고, 이를 정렬하기 위한 용도로 사용됩니다. 각 객체는 클래스 인덱스와 Elo rating 값으로 구성된 쌍으로 나타내어지며, Elo rating 값이 높은 객체일수록 상위에 위치하게 됩니다.
elo_comparator
int total_compares = 0;
int current_class = 0;
int elo_comparator(const void*a, const void *b)
{
sortable_bbox box1 = *(sortable_bbox*)a;
sortable_bbox box2 = *(sortable_bbox*)b;
if(box1.elos[current_class] == box2.elos[current_class]) return 0;
if(box1.elos[current_class] > box2.elos[current_class]) return -1;
return 1;
}함수 이름: elo_comparator
입력:
void 포인터 형태로 정렬할 sortable_bbox 구조체의 주소값인 a와 b
동작:
elo_comparator 함수는 정렬 알고리즘에서 사용되는 비교 함수이다.
두 개의 sortable_bbox 구조체를 비교하여 정렬 순서를 결정한다.
현재 클래스(current_class)에서의 elos 값을 비교하여 내림차순으로 정렬한다.
설명:
total_compares: 전체 비교 수를 나타내는 변수
current_class: 현재 클래스의 인덱스를 나타내는 변수
elo_comparator 함수는 qsort() 함수에서 사용될 비교 함수이다. qsort()는 일반적으로 C/C++에서 사용되는 정렬 함수로, 오름차순 또는 내림차순으로 배열을 정렬할 수 있다.
sortable_bbox 구조체는 bbox.c 파일에서 사용되며, 네트워크, 파일 이름, 클래스, 클래스 수, elo 값 등을 저장한다.
elo_comparator 함수는 두 개의 sortable_bbox 구조체를 받아 각 구조체의 current_class 인덱스에 해당하는 elos 값을 비교한다. elos 값이 높은 것부터 내림차순으로 정렬하며, 만약 elos 값이 같은 경우에는 순서를 바꾸지 않는다.
이 함수는 compare_weights() 함수에서 호출되며, 정렬된 결과는 sorted_boxes에 저장된다.
bbox_comparator
int bbox_comparator(const void *a, const void *b)
{
++total_compares;
sortable_bbox box1 = *(sortable_bbox*)a;
sortable_bbox box2 = *(sortable_bbox*)b;
network net = box1.net;
int class = box1.class;
image im1 = load_image_color(box1.filename, net.w, net.h);
image im2 = load_image_color(box2.filename, net.w, net.h);
float *X = calloc(net.w*net.h*net.c, sizeof(float));
memcpy(X, im1.data, im1.w*im1.h*im1.c*sizeof(float));
memcpy(X+im1.w*im1.h*im1.c, im2.data, im2.w*im2.h*im2.c*sizeof(float));
float *predictions = network_predict(net, X);
free_image(im1);
free_image(im2);
free(X);
if (predictions[class*2] > predictions[class*2+1]){
return 1;
}
return -1;
}함수 이름: bbox_comparator
입력:
const void 포인터 a: 비교하고자 하는 첫 번째 sortable_bbox 구조체의 포인터
const void 포인터 b: 비교하고자 하는 두 번째 sortable_bbox 구조체의 포인터
동작:
total_compares 값을 1 증가시킴
a와 b를 sortable_bbox 구조체로 변환하여 box1, box2에 저장
box1에 저장된 network와 class 값을 사용하여 이미지를 로드하고, X 배열에 이미지 데이터를 복사
box2에 저장된 network와 class 값을 사용하여 이미지를 로드하고, X 배열에 이미지 데이터를 이어붙임
network_predict 함수를 사용하여 X 배열의 예측 값을 계산하여 predictions에 저장
사용한 이미지와 X 배열의 메모리를 해제함
class에 해당하는 예측 값 비교 결과를 반환함
설명:
이 함수는 두 개의 sortable_bbox 구조체를 비교하여 정렬하기 위해 qsort 함수에서 사용됩니다.
두 개의 구조체에서 network와 class 값은 같으므로, 이를 사용하여 두 개의 이미지를 로드하고, 예측 값을 계산하여 비교합니다.
반환 값은 예측 값이 더 큰 경우 1, 그렇지 않은 경우 -1입니다. 이 함수가 호출될 때마다 total_compares 값을 1 씩 증가시켜, 이 함수가 총 몇 번 호출되었는지를 추적합니다.
bbox_update
void bbox_update(sortable_bbox *a, sortable_bbox *b, int class, int result)
{
int k = 32;
float EA = 1./(1+pow(10, (b->elos[class] - a->elos[class])/400.));
float EB = 1./(1+pow(10, (a->elos[class] - b->elos[class])/400.));
float SA = result ? 1 : 0;
float SB = result ? 0 : 1;
a->elos[class] += k*(SA - EA);
b->elos[class] += k*(SB - EB);
}함수 이름: bbox_update
입력:
sortable_bbox 타입의 두 개의 포인터 a와 b, int 타입의 class와 result
동작:
Elo 레이팅 시스템을 사용하여 a와 b의 레이팅을 갱신한다. a와 b는 각각 class와 관련된 Elo 레이팅을 가지고 있으며, result는 a와 b 중 어느 쪽이 승리했는지를 나타낸다. 각각의 레이팅은 SA와 SB로 표현된다.
이전 레이팅에 대한 예상 승률 EA와 EB는 현재 레이팅과 이전 레이팅 사이의 차이를 통해 계산된다.
k는 승리나 패배에 대한 가중치를 조절하는 상수이다.
설명:
Elo 레이팅 시스템은 체스 선수들의 레이팅을 갱신하기 위해 고안된 시스템으로, 이제는 다양한 분야에서 사용되고 있다.
이 함수는 이 시스템을 사용하여 a와 b의 레이팅을 갱신한다.
승리한 쪽의 레이팅은 상대방에 비해 더 큰 증가를 하고, 패배한 쪽은 상대방에 비해 더 큰 감소를 한다.
이전 레이팅과 예상 승률을 비교하여 새로운 레이팅을 계산한다.
bbox_fight
void bbox_fight(network net, sortable_bbox *a, sortable_bbox *b, int classes, int class)
{
image im1 = load_image_color(a->filename, net.w, net.h);
image im2 = load_image_color(b->filename, net.w, net.h);
float *X = calloc(net.w*net.h*net.c, sizeof(float));
memcpy(X, im1.data, im1.w*im1.h*im1.c*sizeof(float));
memcpy(X+im1.w*im1.h*im1.c, im2.data, im2.w*im2.h*im2.c*sizeof(float));
float *predictions = network_predict(net, X);
++total_compares;
int i;
for(i = 0; i < classes; ++i){
if(class < 0 || class == i){
int result = predictions[i*2] > predictions[i*2+1];
bbox_update(a, b, i, result);
}
}
free_image(im1);
free_image(im2);
free(X);
}함수 이름: bbox_fight
입력:
network net: YOLO 모델
sortable_bbox *a: 비교 대상 A
sortable_bbox *b: 비교 대상 B
int classes: 클래스 수
int class: 비교할 클래스 인덱스. 음수이면 모든 클래스 비교
동작:
A와 B를 비교하여 예측값 계산
각 클래스별로, 해당 클래스가 선택된 경우 또는 음수이면 모든 클래스에 대해, A와 B의 elo를 갱신
설명:
두 이미지 a->filename과 b->filename를 YOLO 모델로 예측한 결과(predictions)를 받음
클래스별로 predictions에서 이긴 이미지를 결정하여 bbox_update 함수를 호출하여 elo 값 갱신
갱신된 값은 sortable_bbox 구조체 내 elos 배열에 저장
SortMaster3000
void SortMaster3000(char *filename, char *weightfile)
{
int i = 0;
network net = parse_network_cfg(filename);
if(weightfile){
load_weights(&net, weightfile);
}
srand(time(0));
set_batch_network(&net, 1);
list *plist = get_paths("data/compare.sort.list");
//list *plist = get_paths("data/compare.val.old");
char **paths = (char **)list_to_array(plist);
int N = plist->size;
free_list(plist);
sortable_bbox *boxes = calloc(N, sizeof(sortable_bbox));
printf("Sorting %d boxes...\n", N);
for(i = 0; i < N; ++i){
boxes[i].filename = paths[i];
boxes[i].net = net;
boxes[i].class = 7;
boxes[i].elo = 1500;
}
clock_t time=clock();
qsort(boxes, N, sizeof(sortable_bbox), bbox_comparator);
for(i = 0; i < N; ++i){
printf("%s\n", boxes[i].filename);
}
printf("Sorted in %d compares, %f secs\n", total_compares, sec(clock()-time));
}함수 이름: SortMaster3000
입력:
filename: 정렬할 네트워크 구성 파일 경로
weightfile: 가중치 파일 경로
동작:
filename과 weightfile로부터 네트워크를 파싱하고, 가중치를 불러온다.
네트워크를 1개의 배치로 설정하고, 시드를 초기화한다.
"data/compare.sort.list"에서 파일 경로 리스트를 가져온다.
가져온 리스트의 크기만큼 sortable_bbox 구조체를 생성하고, 파일 경로, 네트워크, 클래스, elo 등의 정보를 저장한다.
qsort를 사용하여 boxes를 정렬한다.
정렬된 boxes의 파일 경로를 출력한다.
총 비교 횟수와 걸린 시간을 출력한다.
설명:
주어진 파일 경로에 있는 네트워크 구성 파일과 가중치 파일을 사용하여 네트워크를 파싱하고, "data/compare.sort.list"에서 파일 경로 리스트를 가져온 후, 해당 경로의 파일들을 sortable_bbox 구조체에 저장합니다.
그리고 qsort를 사용하여 이를 정렬한 후, 파일 경로를 출력하며, 총 비교 횟수와 걸린 시간을 출력합니다.
BattleRoyaleWithCheese
void BattleRoyaleWithCheese(char *filename, char *weightfile)
{
int classes = 20;
int i,j;
network net = parse_network_cfg(filename);
if(weightfile){
load_weights(&net, weightfile);
}
srand(time(0));
set_batch_network(&net, 1);
list *plist = get_paths("data/compare.sort.list");
//list *plist = get_paths("data/compare.small.list");
//list *plist = get_paths("data/compare.cat.list");
//list *plist = get_paths("data/compare.val.old");
char **paths = (char **)list_to_array(plist);
int N = plist->size;
int total = N;
free_list(plist);
sortable_bbox *boxes = calloc(N, sizeof(sortable_bbox));
printf("Battling %d boxes...\n", N);
for(i = 0; i < N; ++i){
boxes[i].filename = paths[i];
boxes[i].net = net;
boxes[i].classes = classes;
boxes[i].elos = calloc(classes, sizeof(float));;
for(j = 0; j < classes; ++j){
boxes[i].elos[j] = 1500;
}
}
int round;
clock_t time=clock();
for(round = 1; round <= 4; ++round){
clock_t round_time=clock();
printf("Round: %d\n", round);
shuffle(boxes, N, sizeof(sortable_bbox));
for(i = 0; i < N/2; ++i){
bbox_fight(net, boxes+i*2, boxes+i*2+1, classes, -1);
}
printf("Round: %f secs, %d remaining\n", sec(clock()-round_time), N);
}
int class;
for (class = 0; class < classes; ++class){
N = total;
current_class = class;
qsort(boxes, N, sizeof(sortable_bbox), elo_comparator);
N /= 2;
for(round = 1; round <= 100; ++round){
clock_t round_time=clock();
printf("Round: %d\n", round);
sorta_shuffle(boxes, N, sizeof(sortable_bbox), 10);
for(i = 0; i < N/2; ++i){
bbox_fight(net, boxes+i*2, boxes+i*2+1, classes, class);
}
qsort(boxes, N, sizeof(sortable_bbox), elo_comparator);
if(round <= 20) N = (N*9/10)/2*2;
printf("Round: %f secs, %d remaining\n", sec(clock()-round_time), N);
}
char buff[256];
sprintf(buff, "results/battle_%d.log", class);
FILE *outfp = fopen(buff, "w");
for(i = 0; i < N; ++i){
fprintf(outfp, "%s %f\n", boxes[i].filename, boxes[i].elos[class]);
}
fclose(outfp);
}
printf("Tournament in %d compares, %f secs\n", total_compares, sec(clock()-time));
}함수 이름: BattleRoyaleWithCheese
입력:
char* filename: 구성 파일 경로
char* weightfile: 사전 학습된 모델 가중치 파일 경로
동작:
지정된 구성 파일을 파싱하여 네트워크를 만들고, 사전 학습된 모델 가중치를 로드한 후, 지정된 목록 파일에서 비교할 이미지 경로 목록을 가져옵니다.
이미지 경로 목록에서 각 이미지에 대한 Elo Rating을 계산합니다. Elo Rating은 두 객체 간의 상대적인 승률을 나타내는 지수입니다.
Elo Rating을 계산하면 높은 순서대로 이미지가 정렬됩니다.
다음으로 Elo Rating이 가장 높은 이미지와 두 번째로 높은 이미지를 뽑아서 싸웁니다.
Elo Rating이 가장 높은 이미지는 Elo Rating이 두 번째로 높은 이미지보다 이길 가능성이 높습니다.
이 과정을 여러 번 반복합니다. 마지막으로 Elo Rating이 가장 높은 이미지를 출력합니다.
설명:
Elo Rating이라는 지수를 사용하여 이미지를 정렬하고, 각 이미지가 얼마나 잘 분류되는지 측정합니다.
이 프로그램은 이미지 분류 문제를 해결하는 데 매우 효과적입니다.
run_compare
void run_compare(int argc, char **argv)
{
if(argc < 4){
fprintf(stderr, "usage: %s %s [train/test/valid] [cfg] [weights (optional)]\n", argv[0], argv[1]);
return;
}
char *cfg = argv[3];
char *weights = (argc > 4) ? argv[4] : 0;
//char *filename = (argc > 5) ? argv[5]: 0;
if(0==strcmp(argv[2], "train")) train_compare(cfg, weights);
else if(0==strcmp(argv[2], "valid")) validate_compare(cfg, weights);
else if(0==strcmp(argv[2], "sort")) SortMaster3000(cfg, weights);
else if(0==strcmp(argv[2], "battle")) BattleRoyaleWithCheese(cfg, weights);
/*
else if(0==strcmp(argv[2], "train")) train_coco(cfg, weights);
else if(0==strcmp(argv[2], "extract")) extract_boxes(cfg, weights);
else if(0==strcmp(argv[2], "valid")) validate_recall(cfg, weights);
*/
}함수 이름: run_compare
입력:
argc: 실행 인자의 개수
argv: 실행 인자들을 저장하는 배열
동작:
실행 인자 개수가 4개 미만이면, 사용법을 출력하고 함수 종료
실행 인자 중에서 cfg와 weights를 설정
실행 인자 중에서 두 번째로 들어온 문자열 값에 따라 train, valid, sort, battle 중 하나의 함수를 실행
주석 처리된 코드는 실행하지 않음
설명:
이 함수는 Darknet의 compare 학습을 위해 사용됨
실행 인자로 train, valid, sort, battle 중 하나와 cfg 파일 경로, weights 파일 경로를 받음
각각의 인자에 따라 해당하는 함수를 실행하며, weights 파일이 없으면 0으로 설정됨
Last updated
Was this helpful?