aboutsummaryrefslogtreecommitdiff
path: root/tests/test_classes.c
blob: 6dcf19fd39af13d2b9804e22f06cdf3f010845bd (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "framesed.h"

#define CHECK(condition) do { \
    if (!(condition)) { \
        fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, #condition); \
        return 1; \
    } \
} while (0)

static int check_result(const framesed_result *result, double duration) {
    CHECK(result->planes && result->num_groups == FRAMESED_CLASS_COUNT);
    CHECK(result->num_frames == (size_t)ceil(duration / FRAMESED_FRAME_STEP));
    for (size_t i = 0; i < result->num_groups * result->num_frames; ++i)
        CHECK(result->planes[i] >= 0.0f && result->planes[i] <= 1.0f);
    int music = 0;
    for (size_t i = 0; i < result->num_events; ++i) {
        const framesed_event *event = &result->events[i];
        CHECK(event->class_group >= 0 && event->class_group < FRAMESED_CLASS_COUNT);
        CHECK(event->label == framesed_class_label((size_t)event->class_group));
        CHECK(event->start >= 0.0 && event->end > event->start && event->end <= duration);
        CHECK(event->score >= 0.50f && event->score <= 1.0f);
        CHECK(i == 0 || result->events[i - 1].start <= event->start);
        if (event->class_group == 253)
            music = 1;
    }
    CHECK(music);
    CHECK(result->num_tracks > 0 && result->track_step == 0.2);
    for (size_t i = 0; i < result->num_tracks; ++i) {
        const framesed_track *track = &result->tracks[i];
        CHECK(track->class_group >= 0 && track->class_group < FRAMESED_CLASS_COUNT);
        CHECK(track->label == framesed_class_label((size_t)track->class_group));
        CHECK(track->count == (result->num_frames + 4) / 5);
        CHECK(i == 0 || result->tracks[i - 1].class_group < track->class_group);
        const float *row = result->planes + (size_t)track->class_group * result->num_frames;
        for (size_t j = 0; j < track->count; ++j) {
            float maximum = 0.0f;
            for (size_t f = j * 5; f < (j + 1) * 5 && f < result->num_frames; ++f)
                if (row[f] > maximum)
                    maximum = row[f];
            CHECK(track->values[j] == maximum);
        }
    }
    return 0;
}

int main(int argc, char **argv) {
    const char *weights = argc > 1 ? argv[1] : "models/framesed_weights.bin";
    /* A partial final frame/window exercises padding and duration clipping. */
    const size_t count = 30u * FRAMESED_SAMPLE_RATE + 137;
    const double duration = (double)count / FRAMESED_SAMPLE_RATE;
    int16_t *samples = malloc(count * sizeof(*samples));
    CHECK(samples);
    for (size_t i = 0; i < count; ++i) {
        const double t = (double)i / FRAMESED_SAMPLE_RATE;
        double value = (sin(2 * M_PI * 261.6 * t) + sin(2 * M_PI * 329.6 * t) +
                        sin(2 * M_PI * 392.0 * t)) / 3;
        value *= 0.65 + 0.35 * sin(2 * M_PI * 4.0 * t);
        samples[i] = (int16_t)(value * 0.10 * 32767.0);
    }
    framesed_t *engine = framesed_create(weights);
    CHECK(engine);
    framesed_options options = {
        .threads = 1, .track_step = 0.2, .keep_planes = 1, .all_classes = 1,
    };
    framesed_result one = {0};
    CHECK(framesed_detect_s16(engine, samples, 10u * FRAMESED_SAMPLE_RATE, &options, &one) == 0);
    CHECK(check_result(&one, 10.0) == 0);
    framesed_logits logits = {0};
    CHECK(framesed_infer_s16(engine, samples, 10u * FRAMESED_SAMPLE_RATE, &logits) == 0);
    CHECK(one.num_frames == logits.frames);
    for (size_t i = 0; i < FRAMESED_CLASS_COUNT * logits.frames; ++i) {
        const float expected = 1.0f / (1.0f + expf(-logits.logits[i]));
        CHECK(fabsf(one.planes[i] - expected) < 2e-7f);
    }
    framesed_logits_free(&logits);
    framesed_result_free(&one);

    CHECK(framesed_detect_s16(engine, samples, count, &options, &one) == 0);
    CHECK(check_result(&one, duration) == 0);
    options.threads = 4;
    framesed_result many = {0};
    CHECK(framesed_detect_s16(engine, samples, count, &options, &many) == 0);
    CHECK(check_result(&many, duration) == 0);
    CHECK(one.num_events == many.num_events && one.num_tracks == many.num_tracks);
    CHECK(one.num_frames == many.num_frames && one.num_groups == many.num_groups);
    CHECK(memcmp(one.planes, many.planes,
                 one.num_frames * one.num_groups * sizeof(float)) == 0);
    for (size_t i = 0; i < one.num_events; ++i) {
        const framesed_event *a = &one.events[i], *b = &many.events[i];
        CHECK(a->class_group == b->class_group && a->label == b->label);
        CHECK(a->start == b->start && a->end == b->end && a->score == b->score);
    }
    for (size_t i = 0; i < one.num_tracks; ++i) {
        const framesed_track *a = &one.tracks[i], *b = &many.tracks[i];
        CHECK(a->class_group == b->class_group && a->label == b->label && a->count == b->count);
        CHECK(memcmp(a->values, b->values, a->count * sizeof(float)) == 0);
    }
    printf("framesed classes: 447 score planes match native logits; 1/4 workers agree "
           "(%zu events, %zu tracks)\n", one.num_events, one.num_tracks);
    framesed_result_free(&one);
    framesed_result_free(&many);
    options.keep_planes = 0;
    options.track_step = 0;
    CHECK(framesed_detect_s16(engine, samples, 10u * FRAMESED_SAMPLE_RATE, &options, &one) == 0);
    CHECK(one.num_events > 0 && !one.planes && !one.tracks);
    CHECK(one.num_groups == 0 && one.num_frames == 0 && one.num_tracks == 0);
    framesed_result_free(&one);
    options.keep_planes = 1;
    CHECK(framesed_detect_s16(engine, samples, 17, &options, &one) == 0);
    CHECK(one.num_groups == FRAMESED_CLASS_COUNT && one.num_frames == 1 && one.planes);
    CHECK(one.num_events == 0);
    framesed_result_free(&one);
    CHECK(framesed_detect_s16(engine, NULL, 0, &options, &one) == 0);
    CHECK(!one.planes && !one.events && !one.tracks);
    framesed_result_free(&one);
    framesed_destroy(engine);
    free(samples);
    return 0;
}