up new v4

Scheaven

2021-06-03 168af40fe9a3cc81c6ee16b3e81f154780c36bdb

 lib/detecter_tools/darknet/gaussian_yolo_layer.c

@@ -51,7 +51,8 @@
    l.outputs = h*w*n*(classes + 8 + 1);

    l.inputs = l.outputs;

    l.max_boxes = max_boxes;

    l.truths = l.max_boxes*(4 + 1);

   l.truth_size = 4 + 2;
    l.truths = l.max_boxes*l.truth_size;
    l.delta = (float*)calloc(batch*l.outputs, sizeof(float));

    l.output = (float*)calloc(batch*l.outputs, sizeof(float));

    for(i = 0; i < total*2; ++i){

@@ -367,7 +368,7 @@
    }

}



void delta_gaussian_yolo_class(float *output, float *delta, int index, int class_id, int classes, int stride, float *avg_cat, float label_smooth_eps, float *classes_multipliers)

void delta_gaussian_yolo_class(float *output, float *delta, int index, int class_id, int classes, int stride, float *avg_cat, float label_smooth_eps, float *classes_multipliers, float cls_normalizer)
{

    int n;

    if (delta[index]){

@@ -385,7 +386,7 @@
        if (label_smooth_eps) y_true = y_true *  (1 - label_smooth_eps) + 0.5*label_smooth_eps;

        delta[index + stride*n] = y_true - output[index + stride*n];



        if (classes_multipliers && n == class_id) delta[index + stride*class_id] *= classes_multipliers[class_id];

        if (classes_multipliers && n == class_id) delta[index + stride*class_id] *= classes_multipliers[class_id] * cls_normalizer;
        if(n == class_id && avg_cat) *avg_cat += output[index + stride*n];

    }

}

@@ -464,8 +465,8 @@
                    float best_iou = 0;

                    int best_t = 0;

                    for(t = 0; t < l.max_boxes; ++t){

                        box truth = float_to_box_stride(state.truth + t*(4 + 1) + b*l.truths, 1);

                        int class_id = state.truth[t*(4 + 1) + b*l.truths + 4];

                        box truth = float_to_box_stride(state.truth + t*l.truth_size + b*l.truths, 1);
                        int class_id = state.truth[t*l.truth_size + b*l.truths + 4];
                        if (class_id >= l.classes) {

                            printf("\n Warning: in txt-labels class_id=%d >= classes=%d in cfg-file. In txt-labels class_id should be [from 0 to %d] \n", class_id, l.classes, l.classes - 1);

                            printf(" truth.x = %f, truth.y = %f, truth.w = %f, truth.h = %f, class_id = %d \n", truth.x, truth.y, truth.w, truth.h, class_id);

@@ -490,23 +491,22 @@
                    }



                    avg_anyobj += l.output[obj_index];

                    l.delta[obj_index] = l.cls_normalizer * (0 - l.output[obj_index]);

                    l.delta[obj_index] = l.obj_normalizer * (0 - l.output[obj_index]);
                    if (best_match_iou > l.ignore_thresh) {

                        const float iou_multiplier = best_match_iou*best_match_iou;// (best_match_iou - l.ignore_thresh) / (1.0 - l.ignore_thresh);

                        if (l.objectness_smooth) {

                            l.delta[obj_index] = l.cls_normalizer * (iou_multiplier - l.output[obj_index]);

                            l.delta[obj_index] = l.obj_normalizer * (iou_multiplier - l.output[obj_index]);


                            int class_id = state.truth[best_match_t*(4 + 1) + b*l.truths + 4];

                            int class_id = state.truth[best_match_t*l.truth_size + b*l.truths + 4];
                            if (l.map) class_id = l.map[class_id];

                            const float class_multiplier = (l.classes_multipliers) ? l.classes_multipliers[class_id] : 1.0f;

                            l.delta[class_index + stride*class_id] = class_multiplier * (iou_multiplier - l.output[class_index + stride*class_id]);

                            delta_gaussian_yolo_class(l.output, l.delta, class_index, class_id, l.classes, l.w*l.h, 0, l.label_smooth_eps, l.classes_multipliers, l.cls_normalizer);
                        }

                        else l.delta[obj_index] = 0;

                    }

                    else if (state.net.adversarial) {

                        float scale = pred.w * pred.h;

                        if (scale > 0) scale = sqrt(scale);

                        l.delta[obj_index] = scale * l.cls_normalizer * (0 - l.output[obj_index]);

                        l.delta[obj_index] = scale * l.obj_normalizer * (0 - l.output[obj_index]);
                        int cl_id;

                        for (cl_id = 0; cl_id < l.classes; ++cl_id) {

                            if (l.output[class_index + stride*cl_id] * l.output[obj_index] > 0.25)

@@ -515,23 +515,23 @@
                    }

                    if (best_iou > l.truth_thresh) {

                        const float iou_multiplier = best_iou*best_iou;// (best_iou - l.truth_thresh) / (1.0 - l.truth_thresh);

                        if (l.objectness_smooth) l.delta[obj_index] = l.cls_normalizer * (iou_multiplier - l.output[obj_index]);

                        else l.delta[obj_index] = l.cls_normalizer * (1 - l.output[obj_index]);

                        //l.delta[obj_index] = l.cls_normalizer * (1 - l.output[obj_index]);

                        if (l.objectness_smooth) l.delta[obj_index] = l.obj_normalizer * (iou_multiplier - l.output[obj_index]);
                        else l.delta[obj_index] = l.obj_normalizer * (1 - l.output[obj_index]);
                        //l.delta[obj_index] = l.obj_normalizer * (1 - l.output[obj_index]);


                        int class_id = state.truth[best_t*(4 + 1) + b*l.truths + 4];

                        int class_id = state.truth[best_t*l.truth_size + b*l.truths + 4];
                        if (l.map) class_id = l.map[class_id];

                        delta_gaussian_yolo_class(l.output, l.delta, class_index, class_id, l.classes, l.w*l.h, 0, l.label_smooth_eps, l.classes_multipliers);

                        delta_gaussian_yolo_class(l.output, l.delta, class_index, class_id, l.classes, l.w*l.h, 0, l.label_smooth_eps, l.classes_multipliers, l.cls_normalizer);
                        const float class_multiplier = (l.classes_multipliers) ? l.classes_multipliers[class_id] : 1.0f;

                        if (l.objectness_smooth) l.delta[class_index + stride*class_id] = class_multiplier * (iou_multiplier - l.output[class_index + stride*class_id]);

                        box truth = float_to_box_stride(state.truth + best_t*(4 + 1) + b*l.truths, 1);

                        box truth = float_to_box_stride(state.truth + best_t*l.truth_size + b*l.truths, 1);
                        delta_gaussian_yolo_box(truth, l.output, l.biases, l.mask[n], box_index, i, j, l.w, l.h, state.net.w, state.net.h, l.delta, (2-truth.w*truth.h), l.w*l.h, l.iou_normalizer * class_multiplier, l.iou_loss, l.uc_normalizer, 1, l.yolo_point, l.max_delta);

                    }

                }

            }

        }

        for(t = 0; t < l.max_boxes; ++t){

            box truth = float_to_box_stride(state.truth + t*(4 + 1) + b*l.truths, 1);

            box truth = float_to_box_stride(state.truth + t*l.truth_size + b*l.truths, 1);


            if(!truth.x) break;

            float best_iou = 0;

@@ -565,7 +565,7 @@


            int mask_n = int_index(l.mask, best_n, l.n);

            if(mask_n >= 0){

                int class_id = state.truth[t*(4 + 1) + b*l.truths + 4];

                int class_id = state.truth[t*l.truth_size + b*l.truths + 4];
                if (l.map) class_id = l.map[class_id];



                int box_index = entry_gaussian_index(l, b, mask_n*l.w*l.h + j*l.w + i, 0);

@@ -574,10 +574,10 @@


                int obj_index = entry_gaussian_index(l, b, mask_n*l.w*l.h + j*l.w + i, 8);

                avg_obj += l.output[obj_index];

                l.delta[obj_index] = class_multiplier * l.cls_normalizer * (1 - l.output[obj_index]);

                l.delta[obj_index] = class_multiplier * l.obj_normalizer * (1 - l.output[obj_index]);


                int class_index = entry_gaussian_index(l, b, mask_n*l.w*l.h + j*l.w + i, 9);

                delta_gaussian_yolo_class(l.output, l.delta, class_index, class_id, l.classes, l.w*l.h, &avg_cat, l.label_smooth_eps, l.classes_multipliers);

                delta_gaussian_yolo_class(l.output, l.delta, class_index, class_id, l.classes, l.w*l.h, &avg_cat, l.label_smooth_eps, l.classes_multipliers, l.cls_normalizer);


                ++count;

                ++class_count;

@@ -598,7 +598,7 @@
                    // iou, n



                    if (iou > l.iou_thresh) {

                        int class_id = state.truth[t*(4 + 1) + b*l.truths + 4];

                        int class_id = state.truth[t*l.truth_size + b*l.truths + 4];
                        if (l.map) class_id = l.map[class_id];



                        int box_index = entry_gaussian_index(l, b, mask_n*l.w*l.h + j*l.w + i, 0);

@@ -607,10 +607,10 @@


                        int obj_index = entry_gaussian_index(l, b, mask_n*l.w*l.h + j*l.w + i, 8);

                        avg_obj += l.output[obj_index];

                        l.delta[obj_index] = class_multiplier * l.cls_normalizer * (1 - l.output[obj_index]);

                        l.delta[obj_index] = class_multiplier * l.obj_normalizer * (1 - l.output[obj_index]);


                        int class_index = entry_gaussian_index(l, b, mask_n*l.w*l.h + j*l.w + i, 9);

                        delta_gaussian_yolo_class(l.output, l.delta, class_index, class_id, l.classes, l.w*l.h, &avg_cat, l.label_smooth_eps, l.classes_multipliers);

                        delta_gaussian_yolo_class(l.output, l.delta, class_index, class_id, l.classes, l.w*l.h, &avg_cat, l.label_smooth_eps, l.classes_multipliers, l.cls_normalizer);


                        ++count;

                        ++class_count;

@@ -894,6 +894,6 @@


void backward_gaussian_yolo_layer_gpu(const layer l, network_state state)

{

    axpy_ongpu(l.batch*l.inputs, 1, l.delta_gpu, 1, state.delta, 1);

    axpy_ongpu(l.batch*l.inputs, l.delta_normalizer, l.delta_gpu, 1, state.delta, 1);
}

#endif